# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.4419521689414982*${_u_distance}
variable latticeconst_converted equal 3.4419521689414982*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.4419521689415
Lattice spacing in x,y,z = 3.4419522 3.4419522 3.4419522
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  create_atoms CPU = 0.005 seconds

variable mass_converted equal 6.941*${_u_mass}
variable mass_converted equal 6.941*1

kim_interactions Li

WARNING: 'kim_<command>' has been renamed to 'kim <command>'. Please update your input.

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_FuemmelerVita_2023_Li__MO_386038428339_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

# initial volume
variable      v equal vol        # assign formula
variable      V0 equal ${v}    # evaluate initial value
variable      V0 equal 40776.9268957422    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 40776.9268957422/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 40776.9268957422/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 40776.9268957422/(1*1*${_u_distance})
variable      V0_metal equal 40776.9268957422/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 40776.9268957422*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 40776.9268957422 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 273.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "273.15 - 0.2"
variable      T_up  equal  "273.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_386038428339_000#item-citation

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3726.5745     -3726.5745     -3797.1541     -3797.1541      273.15         273.15         40776.927      40776.927      1848.7748      1848.7748    
      1000  -3654.5919     -3654.5919     -3724.6114     -3724.6114      270.98249      270.98249      41955.072      41955.072     -518.0136      -518.0136     
Loop time of 130.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.309 hours/ns, 7.650 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.64     | 129.64     | 129.64     |   0.0 | 99.18
Neigh   | 0.45829    | 0.45829    | 0.45829    |   0.0 |  0.35
Comm    | 0.11524    | 0.11524    | 0.11524    |   0.0 |  0.09
Output  | 0.00025657 | 0.00025657 | 0.00025657 |   0.0 |  0.00
Modify  | 0.43022    | 0.43022    | 0.43022    |   0.0 |  0.33
Other   |            | 0.0648     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3835 ave        3835 max        3835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126832 ave      126832 max      126832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126832
Ave neighs/atom = 63.416
Neighbor list builds = 17
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3654.5919     -3654.5919     -3724.6114     -3724.6114      270.98249      270.98249      41955.072      41955.072     -518.0136      -518.0136     
      2000  -3654.3504     -3654.3504     -3724.9092     -3724.9092      273.06987      273.06987      41717.482      41717.482      263.97617      263.97617    
Loop time of 128.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.656 hours/ns, 7.791 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.2      | 127.2      | 127.2      |   0.0 | 99.10
Neigh   | 0.5419     | 0.5419     | 0.5419     |   0.0 |  0.42
Comm    | 0.11694    | 0.11694    | 0.11694    |   0.0 |  0.09
Output  | 0.00020273 | 0.00020273 | 0.00020273 |   0.0 |  0.00
Modify  | 0.43695    | 0.43695    | 0.43695    |   0.0 |  0.34
Other   |            | 0.06494    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3795 ave        3795 max        3795 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127094 ave      127094 max      127094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127094
Ave neighs/atom = 63.547
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3654.3504     -3654.3504     -3724.9092     -3724.9092      273.06987      273.06987      41717.482      41717.482      263.97617      263.97617    
      3000  -3654.7804     -3654.7804     -3724.4001     -3724.4001      269.43545      269.43545      41807.604      41807.604     -68.896357     -68.896357    
Loop time of 126.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.055 hours/ns, 7.924 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.06     | 125.06     | 125.06     |   0.0 | 99.10
Neigh   | 0.53488    | 0.53488    | 0.53488    |   0.0 |  0.42
Comm    | 0.11073    | 0.11073    | 0.11073    |   0.0 |  0.09
Output  | 0.00024678 | 0.00024678 | 0.00024678 |   0.0 |  0.00
Modify  | 0.42375    | 0.42375    | 0.42375    |   0.0 |  0.34
Other   |            | 0.06444    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3809 ave        3809 max        3809 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127386 ave      127386 max      127386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127386
Ave neighs/atom = 63.693
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3654.7804     -3654.7804     -3724.4001     -3724.4001      269.43545      269.43545      41807.604      41807.604     -68.896357     -68.896357    
      4000  -3654.8475     -3654.8475     -3724.5644     -3724.5644      269.8117       269.8117       41854.05       41854.05      -117.79396     -117.79396    
Loop time of 118.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.730 ns/day, 32.869 hours/ns, 8.451 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.26     | 117.26     | 117.26     |   0.0 | 99.10
Neigh   | 0.53456    | 0.53456    | 0.53456    |   0.0 |  0.45
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.09
Output  | 0.0002101  | 0.0002101  | 0.0002101  |   0.0 |  0.00
Modify  | 0.37158    | 0.37158    | 0.37158    |   0.0 |  0.31
Other   |            | 0.06011    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3849 ave        3849 max        3849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126934 ave      126934 max      126934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126934
Ave neighs/atom = 63.467
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3654.8475     -3654.8475     -3724.5644     -3724.5644      269.8117       269.8117       41854.05       41854.05      -117.79396     -117.79396    
      5000  -3653.7492     -3653.7492     -3726.1675     -3726.1675      280.26652      280.26652      41555.769      41555.769      817.39327      817.39327    
Loop time of 126.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.140 hours/ns, 7.905 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.34     | 125.34     | 125.34     |   0.0 | 99.08
Neigh   | 0.56272    | 0.56272    | 0.56272    |   0.0 |  0.44
Comm    | 0.11114    | 0.11114    | 0.11114    |   0.0 |  0.09
Output  | 0.00021318 | 0.00021318 | 0.00021318 |   0.0 |  0.00
Modify  | 0.4236     | 0.4236     | 0.4236     |   0.0 |  0.33
Other   |            | 0.06432    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3837 ave        3837 max        3837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127766 ave      127766 max      127766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127766
Ave neighs/atom = 63.883
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.924464025396, Press = 767.339156984959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3653.7492     -3653.7492     -3726.1675     -3726.1675      280.26652      280.26652      41555.769      41555.769      817.39327      817.39327    
      6000  -3654.7424     -3654.7424     -3725.4493     -3725.4493      273.64299      273.64299      42066.945      42066.945     -876.07711     -876.07711    
Loop time of 126.864 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.240 hours/ns, 7.882 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.67     | 125.67     | 125.67     |   0.0 | 99.06
Neigh   | 0.57016    | 0.57016    | 0.57016    |   0.0 |  0.45
Comm    | 0.11225    | 0.11225    | 0.11225    |   0.0 |  0.09
Output  | 0.0002058  | 0.0002058  | 0.0002058  |   0.0 |  0.00
Modify  | 0.4494     | 0.4494     | 0.4494     |   0.0 |  0.35
Other   |            | 0.06389    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3843 ave        3843 max        3843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126674 ave      126674 max      126674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126674
Ave neighs/atom = 63.337
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.68588787584, Press = 60.3787720101777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3654.7424     -3654.7424     -3725.4493     -3725.4493      273.64299      273.64299      42066.945      42066.945     -876.07711     -876.07711    
      7000  -3654.9456     -3654.9456     -3725.4134     -3725.4134      272.71788      272.71788      41716.959      41716.959      306.0317       306.0317     
Loop time of 126.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.188 hours/ns, 7.894 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.53     | 125.53     | 125.53     |   0.0 | 99.09
Neigh   | 0.53609    | 0.53609    | 0.53609    |   0.0 |  0.42
Comm    | 0.11045    | 0.11045    | 0.11045    |   0.0 |  0.09
Output  | 0.00025041 | 0.00025041 | 0.00025041 |   0.0 |  0.00
Modify  | 0.4416     | 0.4416     | 0.4416     |   0.0 |  0.35
Other   |            | 0.06327    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3846 ave        3846 max        3846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127224 ave      127224 max      127224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127224
Ave neighs/atom = 63.612
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.989526652543, Press = 22.525376187388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3654.9456     -3654.9456     -3725.4134     -3725.4134      272.71788      272.71788      41716.959      41716.959      306.0317       306.0317     
      8000  -3653.9048     -3653.9048     -3725.0374     -3725.0374      275.29071      275.29071      41735.984      41735.984      190.05629      190.05629    
Loop time of 126.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.248 hours/ns, 7.881 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.72     | 125.72     | 125.72     |   0.0 | 99.08
Neigh   | 0.56171    | 0.56171    | 0.56171    |   0.0 |  0.44
Comm    | 0.11047    | 0.11047    | 0.11047    |   0.0 |  0.09
Output  | 0.0001694  | 0.0001694  | 0.0001694  |   0.0 |  0.00
Modify  | 0.43656    | 0.43656    | 0.43656    |   0.0 |  0.34
Other   |            | 0.06266    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127428 ave      127428 max      127428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127428
Ave neighs/atom = 63.714
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.079732094743, Press = 22.7290362757395
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3653.9048     -3653.9048     -3725.0374     -3725.0374      275.29071      275.29071      41735.984      41735.984      190.05629      190.05629    
      9000  -3650.3554     -3650.3554     -3723.7154     -3723.7154      283.91068      283.91068      41894.859      41894.859     -101.3081      -101.3081     
Loop time of 126.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.216 hours/ns, 7.888 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.61     | 125.61     | 125.61     |   0.0 | 99.08
Neigh   | 0.56147    | 0.56147    | 0.56147    |   0.0 |  0.44
Comm    | 0.11099    | 0.11099    | 0.11099    |   0.0 |  0.09
Output  | 0.00020837 | 0.00020837 | 0.00020837 |   0.0 |  0.00
Modify  | 0.4367     | 0.4367     | 0.4367     |   0.0 |  0.34
Other   |            | 0.06328    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3802 ave        3802 max        3802 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127068 ave      127068 max      127068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127068
Ave neighs/atom = 63.534
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.869282211315, Press = 11.0763032175664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3650.3554     -3650.3554     -3723.7154     -3723.7154      283.91068      283.91068      41894.859      41894.859     -101.3081      -101.3081     
     10000  -3656.1014     -3656.1014     -3726.4176     -3726.4176      272.13119      272.13119      41618.041      41618.041      535.43681      535.43681    
Loop time of 126.724 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.201 hours/ns, 7.891 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.53     | 125.53     | 125.53     |   0.0 | 99.06
Neigh   | 0.56345    | 0.56345    | 0.56345    |   0.0 |  0.44
Comm    | 0.11295    | 0.11295    | 0.11295    |   0.0 |  0.09
Output  | 0.00017059 | 0.00017059 | 0.00017059 |   0.0 |  0.00
Modify  | 0.45373    | 0.45373    | 0.45373    |   0.0 |  0.36
Other   |            | 0.06489    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3829 ave        3829 max        3829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127302 ave      127302 max      127302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127302
Ave neighs/atom = 63.651
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.196724881418, Press = 12.2969103386148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3656.1014     -3656.1014     -3726.4176     -3726.4176      272.13119      272.13119      41618.041      41618.041      535.43681      535.43681    
     11000  -3651.9827     -3651.9827     -3723.7931     -3723.7931      277.91365      277.91365      41993.78       41993.78      -539.91483     -539.91483    
Loop time of 126.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.244 hours/ns, 7.882 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.71     | 125.71     | 125.71     |   0.0 | 99.08
Neigh   | 0.56483    | 0.56483    | 0.56483    |   0.0 |  0.45
Comm    | 0.10918    | 0.10918    | 0.10918    |   0.0 |  0.09
Output  | 0.00017142 | 0.00017142 | 0.00017142 |   0.0 |  0.00
Modify  | 0.43253    | 0.43253    | 0.43253    |   0.0 |  0.34
Other   |            | 0.06256    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126754 ave      126754 max      126754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126754
Ave neighs/atom = 63.377
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.230361061757, Press = 13.0290211863974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3651.9827     -3651.9827     -3723.7931     -3723.7931      277.91365      277.91365      41993.78       41993.78      -539.91483     -539.91483    
     12000  -3655.4752     -3655.4752     -3726.0705     -3726.0705      273.21093      273.21093      41755.034      41755.034      138.27164      138.27164    
Loop time of 126.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.111 hours/ns, 7.911 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.21     | 125.21     | 125.21     |   0.0 | 99.06
Neigh   | 0.55889    | 0.55889    | 0.55889    |   0.0 |  0.44
Comm    | 0.1125     | 0.1125     | 0.1125     |   0.0 |  0.09
Output  | 0.0002094  | 0.0002094  | 0.0002094  |   0.0 |  0.00
Modify  | 0.45608    | 0.45608    | 0.45608    |   0.0 |  0.36
Other   |            | 0.06427    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3810 ave        3810 max        3810 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127072 ave      127072 max      127072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127072
Ave neighs/atom = 63.536
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.272465129463, Press = 4.15909221505773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3655.4752     -3655.4752     -3726.0705     -3726.0705      273.21093      273.21093      41755.034      41755.034      138.27164      138.27164    
     13000  -3655.128      -3655.128      -3726.6027     -3726.6027      276.61418      276.61418      41747.351      41747.351      133.68895      133.68895    
Loop time of 126.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.238 hours/ns, 7.883 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.71     | 125.71     | 125.71     |   0.0 | 99.09
Neigh   | 0.53383    | 0.53383    | 0.53383    |   0.0 |  0.42
Comm    | 0.11068    | 0.11068    | 0.11068    |   0.0 |  0.09
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.4419     | 0.4419     | 0.4419     |   0.0 |  0.35
Other   |            | 0.06395    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3855 ave        3855 max        3855 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127090 ave      127090 max      127090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127090
Ave neighs/atom = 63.545
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.779440830957, Press = 10.1331342509138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3655.128      -3655.128      -3726.6027     -3726.6027      276.61418      276.61418      41747.351      41747.351      133.68895      133.68895    
     14000  -3657.999      -3657.999      -3726.2526     -3726.2526      264.14829      264.14829      41847.103      41847.103     -280.30603     -280.30603    
Loop time of 126.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.082 hours/ns, 7.918 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.11     | 125.11     | 125.11     |   0.0 | 99.06
Neigh   | 0.56556    | 0.56556    | 0.56556    |   0.0 |  0.45
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.09
Output  | 0.00020554 | 0.00020554 | 0.00020554 |   0.0 |  0.00
Modify  | 0.44851    | 0.44851    | 0.44851    |   0.0 |  0.36
Other   |            | 0.06411    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126714 ave      126714 max      126714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126714
Ave neighs/atom = 63.357
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.735209635156, Press = 2.57859285462719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3657.999      -3657.999      -3726.2526     -3726.2526      264.14829      264.14829      41847.103      41847.103     -280.30603     -280.30603    
     15000  -3653.6032     -3653.6032     -3724.5985     -3724.5985      274.75936      274.75936      41527.53       41527.53       903.07485      903.07485    
Loop time of 121.432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.731 hours/ns, 8.235 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.31     | 120.31     | 120.31     |   0.0 | 99.08
Neigh   | 0.54413    | 0.54413    | 0.54413    |   0.0 |  0.45
Comm    | 0.10613    | 0.10613    | 0.10613    |   0.0 |  0.09
Output  | 0.00016887 | 0.00016887 | 0.00016887 |   0.0 |  0.00
Modify  | 0.40894    | 0.40894    | 0.40894    |   0.0 |  0.34
Other   |            | 0.06147    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3886 ave        3886 max        3886 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127654 ave      127654 max      127654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127654
Ave neighs/atom = 63.827
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.551030989679, Press = 8.94012495706531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3653.6032     -3653.6032     -3724.5985     -3724.5985      274.75936      274.75936      41527.53       41527.53       903.07485      903.07485    
     16000  -3658.9747     -3658.9747     -3726.3111     -3726.3111      260.59888      260.59888      41948.798      41948.798     -650.48762     -650.48762    
Loop time of 112.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.308 hours/ns, 8.872 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.68     | 111.68     | 111.68     |   0.0 | 99.09
Neigh   | 0.51686    | 0.51686    | 0.51686    |   0.0 |  0.46
Comm    | 0.097027   | 0.097027   | 0.097027   |   0.0 |  0.09
Output  | 0.00016866 | 0.00016866 | 0.00016866 |   0.0 |  0.00
Modify  | 0.35293    | 0.35293    | 0.35293    |   0.0 |  0.31
Other   |            | 0.0575     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3781 ave        3781 max        3781 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126560 ave      126560 max      126560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126560
Ave neighs/atom = 63.28
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.332158946061, Press = 6.23295869399037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3658.9747     -3658.9747     -3726.3111     -3726.3111      260.59888      260.59888      41948.798      41948.798     -650.48762     -650.48762    
     17000  -3653.351      -3653.351      -3723.9883     -3723.9883      273.37345      273.37345      41776.933      41776.933      190.29471      190.29471    
Loop time of 112.636 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.288 hours/ns, 8.878 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.61     | 111.61     | 111.61     |   0.0 | 99.09
Neigh   | 0.51714    | 0.51714    | 0.51714    |   0.0 |  0.46
Comm    | 0.097684   | 0.097684   | 0.097684   |   0.0 |  0.09
Output  | 0.00016817 | 0.00016817 | 0.00016817 |   0.0 |  0.00
Modify  | 0.35166    | 0.35166    | 0.35166    |   0.0 |  0.31
Other   |            | 0.05802    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3860 ave        3860 max        3860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127214 ave      127214 max      127214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127214
Ave neighs/atom = 63.607
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.158654186794, Press = 3.05839172908761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3653.351      -3653.351      -3723.9883     -3723.9883      273.37345      273.37345      41776.933      41776.933      190.29471      190.29471    
     18000  -3658.935      -3658.935      -3726.6993     -3726.6993      262.25503      262.25503      41796.659      41796.659     -169.77447     -169.77447    
Loop time of 112.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.335 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.81     | 111.81     | 111.81     |   0.0 | 99.11
Neigh   | 0.49263    | 0.49263    | 0.49263    |   0.0 |  0.44
Comm    | 0.097988   | 0.097988   | 0.097988   |   0.0 |  0.09
Output  | 0.00020645 | 0.00020645 | 0.00020645 |   0.0 |  0.00
Modify  | 0.35105    | 0.35105    | 0.35105    |   0.0 |  0.31
Other   |            | 0.05785    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3828 ave        3828 max        3828 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126968 ave      126968 max      126968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126968
Ave neighs/atom = 63.484
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.057394817777, Press = 6.40074870807709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3658.935      -3658.935      -3726.6993     -3726.6993      262.25503      262.25503      41796.659      41796.659     -169.77447     -169.77447    
     19000  -3653.3074     -3653.3074     -3722.6815     -3722.6815      268.48484      268.48484      41909.94       41909.94      -282.14013     -282.14013    
Loop time of 112.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.316 hours/ns, 8.870 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.71     | 111.71     | 111.71     |   0.0 | 99.09
Neigh   | 0.51626    | 0.51626    | 0.51626    |   0.0 |  0.46
Comm    | 0.097807   | 0.097807   | 0.097807   |   0.0 |  0.09
Output  | 0.00016749 | 0.00016749 | 0.00016749 |   0.0 |  0.00
Modify  | 0.35248    | 0.35248    | 0.35248    |   0.0 |  0.31
Other   |            | 0.05795    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3832 ave        3832 max        3832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126956 ave      126956 max      126956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126956
Ave neighs/atom = 63.478
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.980719783978, Press = 2.84752931444174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3653.3074     -3653.3074     -3722.6815     -3722.6815      268.48484      268.48484      41909.94       41909.94      -282.14013     -282.14013    
     20000  -3652.1952     -3652.1952     -3724.2499     -3724.2499      278.85904      278.85904      41728.182      41728.182      210.27802      210.27802    
Loop time of 112.625 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.285 hours/ns, 8.879 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.6      | 111.6      | 111.6      |   0.0 | 99.09
Neigh   | 0.51598    | 0.51598    | 0.51598    |   0.0 |  0.46
Comm    | 0.097395   | 0.097395   | 0.097395   |   0.0 |  0.09
Output  | 0.00017004 | 0.00017004 | 0.00017004 |   0.0 |  0.00
Modify  | 0.35233    | 0.35233    | 0.35233    |   0.0 |  0.31
Other   |            | 0.05803    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3829 ave        3829 max        3829 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127440 ave      127440 max      127440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127440
Ave neighs/atom = 63.72
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.945665713269, Press = 4.31154362695433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3652.1952     -3652.1952     -3724.2499     -3724.2499      278.85904      278.85904      41728.182      41728.182      210.27802      210.27802    
     21000  -3655.8354     -3655.8354     -3725.7105     -3725.7105      270.42382      270.42382      41953.335      41953.335     -467.58151     -467.58151    
Loop time of 112.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.255 hours/ns, 8.888 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.49     | 111.49     | 111.49     |   0.0 | 99.09
Neigh   | 0.51602    | 0.51602    | 0.51602    |   0.0 |  0.46
Comm    | 0.097557   | 0.097557   | 0.097557   |   0.0 |  0.09
Output  | 0.00017036 | 0.00017036 | 0.00017036 |   0.0 |  0.00
Modify  | 0.35146    | 0.35146    | 0.35146    |   0.0 |  0.31
Other   |            | 0.05835    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126920 ave      126920 max      126920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126920
Ave neighs/atom = 63.46
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.076869478389, Press = 3.91152191241394
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3655.8354     -3655.8354     -3725.7105     -3725.7105      270.42382      270.42382      41953.335      41953.335     -467.58151     -467.58151    
     22000  -3652.5886     -3652.5886     -3723.8634     -3723.8634      275.84066      275.84066      41725.343      41725.343      408.95321      408.95321    
Loop time of 112.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.248 hours/ns, 8.889 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.47     | 111.47     | 111.47     |   0.0 | 99.09
Neigh   | 0.51739    | 0.51739    | 0.51739    |   0.0 |  0.46
Comm    | 0.09715    | 0.09715    | 0.09715    |   0.0 |  0.09
Output  | 0.00016784 | 0.00016784 | 0.00016784 |   0.0 |  0.00
Modify  | 0.354      | 0.354      | 0.354      |   0.0 |  0.31
Other   |            | 0.05787    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126954 ave      126954 max      126954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126954
Ave neighs/atom = 63.477
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.088472722214, Press = 1.19018032917659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3652.5886     -3652.5886     -3723.8634     -3723.8634      275.84066      275.84066      41725.343      41725.343      408.95321      408.95321    
     23000  -3654.9512     -3654.9512     -3725.8297     -3725.8297      274.3071       274.3071       41867.945      41867.945     -246.50762     -246.50762    
Loop time of 122.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.906 hours/ns, 8.193 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.97     | 120.97     | 120.97     |   0.0 | 99.10
Neigh   | 0.52102    | 0.52102    | 0.52102    |   0.0 |  0.43
Comm    | 0.10572    | 0.10572    | 0.10572    |   0.0 |  0.09
Output  | 0.00026088 | 0.00026088 | 0.00026088 |   0.0 |  0.00
Modify  | 0.40472    | 0.40472    | 0.40472    |   0.0 |  0.33
Other   |            | 0.06129    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3826 ave        3826 max        3826 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127108 ave      127108 max      127108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127108
Ave neighs/atom = 63.554
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.014681652424, Press = 5.31907824697459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3654.9512     -3654.9512     -3725.8297     -3725.8297      274.3071       274.3071       41867.945      41867.945     -246.50762     -246.50762    
     24000  -3650.9213     -3650.9213     -3723.1326     -3723.1326      279.46529      279.46529      41826.112      41826.112      4.6806041      4.6806041    
Loop time of 126.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.088 hours/ns, 7.917 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.14     | 125.14     | 125.14     |   0.0 | 99.07
Neigh   | 0.56139    | 0.56139    | 0.56139    |   0.0 |  0.44
Comm    | 0.1113     | 0.1113     | 0.1113     |   0.0 |  0.09
Output  | 0.00024239 | 0.00024239 | 0.00024239 |   0.0 |  0.00
Modify  | 0.44333    | 0.44333    | 0.44333    |   0.0 |  0.35
Other   |            | 0.06364    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3822 ave        3822 max        3822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127110 ave      127110 max      127110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127110
Ave neighs/atom = 63.555
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.135436307187, Press = 2.15592825407261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3650.9213     -3650.9213     -3723.1326     -3723.1326      279.46529      279.46529      41826.112      41826.112      4.6806041      4.6806041    
     25000  -3653.7784     -3653.7784     -3724.5047     -3724.5047      273.71799      273.71799      41862.304      41862.304     -223.55558     -223.55558    
Loop time of 125.624 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.896 hours/ns, 7.960 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.49     | 124.49     | 124.49     |   0.0 | 99.09
Neigh   | 0.52704    | 0.52704    | 0.52704    |   0.0 |  0.42
Comm    | 0.10921    | 0.10921    | 0.10921    |   0.0 |  0.09
Output  | 0.00016762 | 0.00016762 | 0.00016762 |   0.0 |  0.00
Modify  | 0.43802    | 0.43802    | 0.43802    |   0.0 |  0.35
Other   |            | 0.06346    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3816 ave        3816 max        3816 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126858 ave      126858 max      126858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126858
Ave neighs/atom = 63.429
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.173376314447, Press = 3.3263379691241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3653.7784     -3653.7784     -3724.5047     -3724.5047      273.71799      273.71799      41862.304      41862.304     -223.55558     -223.55558    
     26000  -3656.2046     -3656.2046     -3724.4898     -3724.4898      264.27074      264.27074      41760.155      41760.155      118.15239      118.15239    
Loop time of 116.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.743 ns/day, 32.286 hours/ns, 8.604 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.16     | 115.16     | 115.16     |   0.0 | 99.08
Neigh   | 0.52728    | 0.52728    | 0.52728    |   0.0 |  0.45
Comm    | 0.1026     | 0.1026     | 0.1026     |   0.0 |  0.09
Output  | 0.00017166 | 0.00017166 | 0.00017166 |   0.0 |  0.00
Modify  | 0.37853    | 0.37853    | 0.37853    |   0.0 |  0.33
Other   |            | 0.05943    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3793 ave        3793 max        3793 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127074 ave      127074 max      127074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127074
Ave neighs/atom = 63.537
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.252807405624, Press = 2.49983233243484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3656.2046     -3656.2046     -3724.4898     -3724.4898      264.27074      264.27074      41760.155      41760.155      118.15239      118.15239    
     27000  -3653.0582     -3653.0582     -3724.5323     -3724.5323      276.6123       276.6123       41789.243      41789.243      14.027387      14.027387    
Loop time of 112.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.380 hours/ns, 8.852 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.96     | 111.96     | 111.96     |   0.0 | 99.11
Neigh   | 0.49325    | 0.49325    | 0.49325    |   0.0 |  0.44
Comm    | 0.098915   | 0.098915   | 0.098915   |   0.0 |  0.09
Output  | 0.00017016 | 0.00017016 | 0.00017016 |   0.0 |  0.00
Modify  | 0.35711    | 0.35711    | 0.35711    |   0.0 |  0.32
Other   |            | 0.05862    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3855 ave        3855 max        3855 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127140 ave      127140 max      127140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127140
Ave neighs/atom = 63.57
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.21578599358, Press = 1.94985286231206
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3653.0582     -3653.0582     -3724.5323     -3724.5323      276.6123       276.6123       41789.243      41789.243      14.027387      14.027387    
     28000  -3655.5751     -3655.5751     -3725.619      -3725.619       271.07742      271.07742      41803.045      41803.045     -73.289835     -73.289835    
Loop time of 113.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.480 hours/ns, 8.824 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.32     | 112.32     | 112.32     |   0.0 | 99.11
Neigh   | 0.49438    | 0.49438    | 0.49438    |   0.0 |  0.44
Comm    | 0.099478   | 0.099478   | 0.099478   |   0.0 |  0.09
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.31
Other   |            | 0.05811    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127142 ave      127142 max      127142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127142
Ave neighs/atom = 63.571
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.098243130915, Press = 3.53152257700664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3655.5751     -3655.5751     -3725.619      -3725.619       271.07742      271.07742      41803.045      41803.045     -73.289835     -73.289835    
     29000  -3657.7633     -3657.7633     -3726.6124     -3726.6124      266.45289      266.45289      41807.626      41807.626     -127.55462     -127.55462    
Loop time of 112.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.385 hours/ns, 8.851 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.95     | 111.95     | 111.95     |   0.0 | 99.09
Neigh   | 0.51945    | 0.51945    | 0.51945    |   0.0 |  0.46
Comm    | 0.099067   | 0.099067   | 0.099067   |   0.0 |  0.09
Output  | 0.00022935 | 0.00022935 | 0.00022935 |   0.0 |  0.00
Modify  | 0.35644    | 0.35644    | 0.35644    |   0.0 |  0.32
Other   |            | 0.05813    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3832 ave        3832 max        3832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126872 ave      126872 max      126872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126872
Ave neighs/atom = 63.436
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.080407107955, Press = 0.940673866593965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3657.7633     -3657.7633     -3726.6124     -3726.6124      266.45289      266.45289      41807.626      41807.626     -127.55462     -127.55462    
     30000  -3654.3337     -3654.3337     -3726.6074     -3726.6074      279.70675      279.70675      41690.853      41690.853      376.08396      376.08396    
Loop time of 113.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.505 hours/ns, 8.817 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.09
Neigh   | 0.51818    | 0.51818    | 0.51818    |   0.0 |  0.46
Comm    | 0.0993     | 0.0993     | 0.0993     |   0.0 |  0.09
Output  | 0.00017093 | 0.00017093 | 0.00017093 |   0.0 |  0.00
Modify  | 0.35721    | 0.35721    | 0.35721    |   0.0 |  0.31
Other   |            | 0.05819    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3840 ave        3840 max        3840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127114 ave      127114 max      127114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127114
Ave neighs/atom = 63.557
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.989212986582, Press = 3.09589830620127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3654.3337     -3654.3337     -3726.6074     -3726.6074      279.70675      279.70675      41690.853      41690.853      376.08396      376.08396    
     31000  -3654.4041     -3654.4041     -3725.016      -3725.016       273.27521      273.27521      41986.393      41986.393     -498.42158     -498.42158    
Loop time of 112.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.361 hours/ns, 8.857 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.89     | 111.89     | 111.89     |   0.0 | 99.11
Neigh   | 0.49426    | 0.49426    | 0.49426    |   0.0 |  0.44
Comm    | 0.099628   | 0.099628   | 0.099628   |   0.0 |  0.09
Output  | 0.0001716  | 0.0001716  | 0.0001716  |   0.0 |  0.00
Modify  | 0.35688    | 0.35688    | 0.35688    |   0.0 |  0.32
Other   |            | 0.0582     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3791 ave        3791 max        3791 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126580 ave      126580 max      126580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126580
Ave neighs/atom = 63.29
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.05298450639, Press = 1.53441680005926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3654.4041     -3654.4041     -3725.016      -3725.016       273.27521      273.27521      41986.393      41986.393     -498.42158     -498.42158    
     32000  -3654.2744     -3654.2744     -3725.507      -3725.507       275.67773      275.67773      41716.148      41716.148      219.27278      219.27278    
Loop time of 113.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.418 hours/ns, 8.841 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.09
Neigh   | 0.51818    | 0.51818    | 0.51818    |   0.0 |  0.46
Comm    | 0.098666   | 0.098666   | 0.098666   |   0.0 |  0.09
Output  | 0.00017031 | 0.00017031 | 0.00017031 |   0.0 |  0.00
Modify  | 0.35705    | 0.35705    | 0.35705    |   0.0 |  0.32
Other   |            | 0.05908    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3866 ave        3866 max        3866 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127174 ave      127174 max      127174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127174
Ave neighs/atom = 63.587
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.049710931498, Press = 1.42063521455317
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3654.2744     -3654.2744     -3725.507      -3725.507       275.67773      275.67773      41716.148      41716.148      219.27278      219.27278    
     33000  -3657.2271     -3657.2271     -3726.6332     -3726.6332      268.6087       268.6087       41770.58       41770.58      -62.676145     -62.676145    
Loop time of 112.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.388 hours/ns, 8.850 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.99     | 111.99     | 111.99     |   0.0 | 99.11
Neigh   | 0.49322    | 0.49322    | 0.49322    |   0.0 |  0.44
Comm    | 0.098061   | 0.098061   | 0.098061   |   0.0 |  0.09
Output  | 0.00017062 | 0.00017062 | 0.00017062 |   0.0 |  0.00
Modify  | 0.35771    | 0.35771    | 0.35771    |   0.0 |  0.32
Other   |            | 0.06048    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127116 ave      127116 max      127116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127116
Ave neighs/atom = 63.558
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.975564190969, Press = 2.40304391635456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3657.2271     -3657.2271     -3726.6332     -3726.6332      268.6087       268.6087       41770.58       41770.58      -62.676145     -62.676145    
     34000  -3653.3751     -3653.3751     -3725.6458     -3725.6458      279.69496      279.69496      41845.929      41845.929     -75.847459     -75.847459    
Loop time of 112.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.316 hours/ns, 8.870 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.73     | 111.73     | 111.73     |   0.0 | 99.11
Neigh   | 0.49233    | 0.49233    | 0.49233    |   0.0 |  0.44
Comm    | 0.098637   | 0.098637   | 0.098637   |   0.0 |  0.09
Output  | 0.00017113 | 0.00017113 | 0.00017113 |   0.0 |  0.00
Modify  | 0.35702    | 0.35702    | 0.35702    |   0.0 |  0.32
Other   |            | 0.05916    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3833 ave        3833 max        3833 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127016 ave      127016 max      127016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127016
Ave neighs/atom = 63.508
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.971879739018, Press = 1.33452846131825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3653.3751     -3653.3751     -3725.6458     -3725.6458      279.69496      279.69496      41845.929      41845.929     -75.847459     -75.847459    
     35000  -3655.6749     -3655.6749     -3724.4893     -3724.4893      266.31858      266.31858      41684.87       41684.87       344.1933       344.1933     
Loop time of 113.184 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.440 hours/ns, 8.835 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.15     | 112.15     | 112.15     |   0.0 | 99.08
Neigh   | 0.52008    | 0.52008    | 0.52008    |   0.0 |  0.46
Comm    | 0.099626   | 0.099626   | 0.099626   |   0.0 |  0.09
Output  | 0.00017204 | 0.00017204 | 0.00017204 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  0.32
Other   |            | 0.05823    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3796 ave        3796 max        3796 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127176 ave      127176 max      127176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127176
Ave neighs/atom = 63.588
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.03402487367, Press = 1.71467162022297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3655.6749     -3655.6749     -3724.4893     -3724.4893      266.31858      266.31858      41684.87       41684.87       344.1933       344.1933     
     36000  -3650.874      -3650.874      -3722.0093     -3722.0093      275.30093      275.30093      41874.839      41874.839     -152.97288     -152.97288    
Loop time of 113.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.411 hours/ns, 8.843 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.11
Neigh   | 0.49549    | 0.49549    | 0.49549    |   0.0 |  0.44
Comm    | 0.098833   | 0.098833   | 0.098833   |   0.0 |  0.09
Output  | 0.00021266 | 0.00021266 | 0.00021266 |   0.0 |  0.00
Modify  | 0.35706    | 0.35706    | 0.35706    |   0.0 |  0.32
Other   |            | 0.05849    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3787 ave        3787 max        3787 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126848 ave      126848 max      126848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126848
Ave neighs/atom = 63.424
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.072086542831, Press = 1.95369940904921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3650.874      -3650.874      -3722.0093     -3722.0093      275.30093      275.30093      41874.839      41874.839     -152.97288     -152.97288    
     37000  -3654.5955     -3654.5955     -3726.5745     -3726.5745      278.56641      278.56641      41810.695      41810.695     -15.55721      -15.55721     
Loop time of 113.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.418 hours/ns, 8.841 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.08
Neigh   | 0.52042    | 0.52042    | 0.52042    |   0.0 |  0.46
Comm    | 0.099349   | 0.099349   | 0.099349   |   0.0 |  0.09
Output  | 0.00017022 | 0.00017022 | 0.00017022 |   0.0 |  0.00
Modify  | 0.35864    | 0.35864    | 0.35864    |   0.0 |  0.32
Other   |            | 0.05873    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3805 ave        3805 max        3805 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126932 ave      126932 max      126932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126932
Ave neighs/atom = 63.466
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.134421974042, Press = 0.56747262928049
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3654.5955     -3654.5955     -3726.5745     -3726.5745      278.56641      278.56641      41810.695      41810.695     -15.55721      -15.55721     
     38000  -3657.1836     -3657.1836     -3727.5944     -3727.5944      272.49697      272.49697      41615.828      41615.828      584.48254      584.48254    
Loop time of 113.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.480 hours/ns, 8.824 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.32     | 112.32     | 112.32     |   0.0 | 99.11
Neigh   | 0.49443    | 0.49443    | 0.49443    |   0.0 |  0.44
Comm    | 0.099415   | 0.099415   | 0.099415   |   0.0 |  0.09
Output  | 0.00045123 | 0.00045123 | 0.00045123 |   0.0 |  0.00
Modify  | 0.35836    | 0.35836    | 0.35836    |   0.0 |  0.32
Other   |            | 0.05804    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3857 ave        3857 max        3857 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127230 ave      127230 max      127230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127230
Ave neighs/atom = 63.615
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.104984834172, Press = 2.8035484584063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3657.1836     -3657.1836     -3727.5944     -3727.5944      272.49697      272.49697      41615.828      41615.828      584.48254      584.48254    
     39000  -3655.8024     -3655.8024     -3727.269      -3727.269       276.5831       276.5831       41918.2        41918.2       -417.77056     -417.77056    
Loop time of 113.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.417 hours/ns, 8.842 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.07     | 112.07     | 112.07     |   0.0 | 99.09
Neigh   | 0.51801    | 0.51801    | 0.51801    |   0.0 |  0.46
Comm    | 0.099739   | 0.099739   | 0.099739   |   0.0 |  0.09
Output  | 0.00017015 | 0.00017015 | 0.00017015 |   0.0 |  0.00
Modify  | 0.3585     | 0.3585     | 0.3585     |   0.0 |  0.32
Other   |            | 0.05826    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3778 ave        3778 max        3778 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126788 ave      126788 max      126788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126788
Ave neighs/atom = 63.394
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.126416594643, Press = 1.45595885084372
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3655.8024     -3655.8024     -3727.269      -3727.269       276.5831       276.5831       41918.2        41918.2       -417.77056     -417.77056    
     40000  -3652.395      -3652.395      -3724.5205     -3724.5205      279.1332       279.1332       41761.172      41761.172      196.18732      196.18732    
Loop time of 112.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.342 hours/ns, 8.863 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.8      | 111.8      | 111.8      |   0.0 | 99.09
Neigh   | 0.51698    | 0.51698    | 0.51698    |   0.0 |  0.46
Comm    | 0.098099   | 0.098099   | 0.098099   |   0.0 |  0.09
Output  | 0.00017003 | 0.00017003 | 0.00017003 |   0.0 |  0.00
Modify  | 0.35723    | 0.35723    | 0.35723    |   0.0 |  0.32
Other   |            | 0.05829    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3821 ave        3821 max        3821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127060 ave      127060 max      127060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127060
Ave neighs/atom = 63.53
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.161842777493, Press = 1.41077194863157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3652.395      -3652.395      -3724.5205     -3724.5205      279.1332       279.1332       41761.172      41761.172      196.18732      196.18732    
     41000  -3655.2523     -3655.2523     -3725.127      -3725.127       270.42237      270.42237      41787.522      41787.522     -42.838217     -42.838217    
Loop time of 112.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.245 hours/ns, 8.890 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.48     | 111.48     | 111.48     |   0.0 | 99.11
Neigh   | 0.49258    | 0.49258    | 0.49258    |   0.0 |  0.44
Comm    | 0.097384   | 0.097384   | 0.097384   |   0.0 |  0.09
Output  | 0.00016975 | 0.00016975 | 0.00016975 |   0.0 |  0.00
Modify  | 0.35478    | 0.35478    | 0.35478    |   0.0 |  0.32
Other   |            | 0.05833    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3813 ave        3813 max        3813 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127156 ave      127156 max      127156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127156
Ave neighs/atom = 63.578
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.209921591515, Press = 1.35293733849133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3655.2523     -3655.2523     -3725.127      -3725.127       270.42237      270.42237      41787.522      41787.522     -42.838217     -42.838217    
     42000  -3651.0644     -3651.0644     -3723.4454     -3723.4454      280.1218       280.1218       41849.268      41849.268     -24.966224     -24.966224    
Loop time of 112.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.282 hours/ns, 8.880 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.61     | 111.61     | 111.61     |   0.0 | 99.11
Neigh   | 0.49216    | 0.49216    | 0.49216    |   0.0 |  0.44
Comm    | 0.097437   | 0.097437   | 0.097437   |   0.0 |  0.09
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.35515    | 0.35515    | 0.35515    |   0.0 |  0.32
Other   |            | 0.05836    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3826 ave        3826 max        3826 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127010 ave      127010 max      127010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127010
Ave neighs/atom = 63.505
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.243677969145, Press = 1.32595515770164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3651.0644     -3651.0644     -3723.4454     -3723.4454      280.1218       280.1218       41849.268      41849.268     -24.966224     -24.966224    
     43000  -3655.6061     -3655.6061     -3726.2948     -3726.2948      273.57253      273.57253      41807.85       41807.85       2.9728291      2.9728291    
Loop time of 112.628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.286 hours/ns, 8.879 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.63     | 111.63     | 111.63     |   0.0 | 99.11
Neigh   | 0.49275    | 0.49275    | 0.49275    |   0.0 |  0.44
Comm    | 0.096756   | 0.096756   | 0.096756   |   0.0 |  0.09
Output  | 0.00020515 | 0.00020515 | 0.00020515 |   0.0 |  0.00
Modify  | 0.35363    | 0.35363    | 0.35363    |   0.0 |  0.31
Other   |            | 0.05866    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3835 ave        3835 max        3835 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127356 ave      127356 max      127356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127356
Ave neighs/atom = 63.678
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.281401302298, Press = 1.76991595606566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -3655.6061     -3655.6061     -3726.2948     -3726.2948      273.57253      273.57253      41807.85       41807.85       2.9728291      2.9728291    
     44000  -3651.0693     -3651.0693     -3723.5067     -3723.5067      280.34006      280.34006      41846.439      41846.439      7.9912198      7.9912198    
Loop time of 112.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.232 hours/ns, 8.894 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.41     | 111.41     | 111.41     |   0.0 | 99.09
Neigh   | 0.51668    | 0.51668    | 0.51668    |   0.0 |  0.46
Comm    | 0.096812   | 0.096812   | 0.096812   |   0.0 |  0.09
Output  | 0.00016787 | 0.00016787 | 0.00016787 |   0.0 |  0.00
Modify  | 0.35405    | 0.35405    | 0.35405    |   0.0 |  0.31
Other   |            | 0.05868    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3779 ave        3779 max        3779 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127060 ave      127060 max      127060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127060
Ave neighs/atom = 63.53
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.315020172861, Press = 0.732698888133867
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -3651.0693     -3651.0693     -3723.5067     -3723.5067      280.34006      280.34006      41846.439      41846.439      7.9912198      7.9912198    
     45000  -3654.1251     -3654.1251     -3724.1337     -3724.1337      270.94049      270.94049      41727.698      41727.698      326.43678      326.43678    
Loop time of 112.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.323 hours/ns, 8.868 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.76     | 111.76     | 111.76     |   0.0 | 99.11
Neigh   | 0.49268    | 0.49268    | 0.49268    |   0.0 |  0.44
Comm    | 0.097508   | 0.097508   | 0.097508   |   0.0 |  0.09
Output  | 0.00016859 | 0.00016859 | 0.00016859 |   0.0 |  0.00
Modify  | 0.3536     | 0.3536     | 0.3536     |   0.0 |  0.31
Other   |            | 0.05868    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3876 ave        3876 max        3876 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127358 ave      127358 max      127358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127358
Ave neighs/atom = 63.679
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.331563461836, Press = 2.63877702601245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3654.1251     -3654.1251     -3724.1337     -3724.1337      270.94049      270.94049      41727.698      41727.698      326.43678      326.43678    
     46000  -3656.9462     -3656.9462     -3723.7856     -3723.7856      258.67542      258.67542      42092.273      42092.273     -1013.19       -1013.19      
Loop time of 112.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.234 hours/ns, 8.894 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.41     | 111.41     | 111.41     |   0.0 | 99.09
Neigh   | 0.5169     | 0.5169     | 0.5169     |   0.0 |  0.46
Comm    | 0.097064   | 0.097064   | 0.097064   |   0.0 |  0.09
Output  | 0.00016903 | 0.00016903 | 0.00016903 |   0.0 |  0.00
Modify  | 0.35477    | 0.35477    | 0.35477    |   0.0 |  0.32
Other   |            | 0.05878    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3739 ave        3739 max        3739 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126534 ave      126534 max      126534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126534
Ave neighs/atom = 63.267
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.361747431011, Press = 0.309412166339017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -3656.9462     -3656.9462     -3723.7856     -3723.7856      258.67542      258.67542      42092.273      42092.273     -1013.19       -1013.19      
     47000  -3655.3448     -3655.3448     -3727.1916     -3727.1916      278.05478      278.05478      41647.292      41647.292      480.88386      480.88386    
Loop time of 112.662 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.295 hours/ns, 8.876 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.63     | 111.63     | 111.63     |   0.0 | 99.09
Neigh   | 0.51635    | 0.51635    | 0.51635    |   0.0 |  0.46
Comm    | 0.09791    | 0.09791    | 0.09791    |   0.0 |  0.09
Output  | 0.00016838 | 0.00016838 | 0.00016838 |   0.0 |  0.00
Modify  | 0.35573    | 0.35573    | 0.35573    |   0.0 |  0.32
Other   |            | 0.05871    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3814 ave        3814 max        3814 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127390 ave      127390 max      127390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127390
Ave neighs/atom = 63.695
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.383880880963, Press = 1.53474528435358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -3655.3448     -3655.3448     -3727.1916     -3727.1916      278.05478      278.05478      41647.292      41647.292      480.88386      480.88386    
     48000  -3654.9162     -3654.9162     -3725.6792     -3725.6792      273.85986      273.85986      41885.878      41885.878     -343.62844     -343.62844    
Loop time of 112.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.324 hours/ns, 8.868 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.76     | 111.76     | 111.76     |   0.0 | 99.11
Neigh   | 0.49229    | 0.49229    | 0.49229    |   0.0 |  0.44
Comm    | 0.098005   | 0.098005   | 0.098005   |   0.0 |  0.09
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.32
Other   |            | 0.059      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3776 ave        3776 max        3776 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127024 ave      127024 max      127024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127024
Ave neighs/atom = 63.512
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.354336319757, Press = 1.12213712693452
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -3654.9162     -3654.9162     -3725.6792     -3725.6792      273.85986      273.85986      41885.878      41885.878     -343.62844     -343.62844    
     49000  -3654.4561     -3654.4561     -3724.3815     -3724.3815      270.61865      270.61865      41698.464      41698.464      322.37367      322.37367    
Loop time of 112.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.314 hours/ns, 8.871 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.71     | 111.71     | 111.71     |   0.0 | 99.10
Neigh   | 0.50549    | 0.50549    | 0.50549    |   0.0 |  0.45
Comm    | 0.096761   | 0.096761   | 0.096761   |   0.0 |  0.09
Output  | 0.00016707 | 0.00016707 | 0.00016707 |   0.0 |  0.00
Modify  | 0.35596    | 0.35596    | 0.35596    |   0.0 |  0.32
Other   |            | 0.05886    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3851 ave        3851 max        3851 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127408 ave      127408 max      127408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127408
Ave neighs/atom = 63.704
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.353269769122, Press = 1.0212825006303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -3654.4561     -3654.4561     -3724.3815     -3724.3815      270.61865      270.61865      41698.464      41698.464      322.37367      322.37367    
     50000  -3653.4396     -3653.4396     -3723.8498     -3723.8498      272.49454      272.49454      41993.018      41993.018     -591.19153     -591.19153    
Loop time of 125.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.732 hours/ns, 7.998 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.87     | 123.87     | 123.87     |   0.0 | 99.07
Neigh   | 0.55597    | 0.55597    | 0.55597    |   0.0 |  0.44
Comm    | 0.11001    | 0.11001    | 0.11001    |   0.0 |  0.09
Output  | 0.0001702  | 0.0001702  | 0.0001702  |   0.0 |  0.00
Modify  | 0.43137    | 0.43137    | 0.43137    |   0.0 |  0.35
Other   |            | 0.06345    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126868 ave      126868 max      126868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126868
Ave neighs/atom = 63.434
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.319558023255, Press = 1.46577619819148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -3653.4396     -3653.4396     -3723.8498     -3723.8498      272.49454      272.49454      41993.018      41993.018     -591.19153     -591.19153    
     51000  -3654.4531     -3654.4531     -3725.6644     -3725.6644      275.59538      275.59538      41589.453      41589.453      674.5171       674.5171     
Loop time of 115.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.747 ns/day, 32.110 hours/ns, 8.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.53     | 114.53     | 114.53     |   0.0 | 99.08
Neigh   | 0.52995    | 0.52995    | 0.52995    |   0.0 |  0.46
Comm    | 0.10105    | 0.10105    | 0.10105    |   0.0 |  0.09
Output  | 0.00017136 | 0.00017136 | 0.00017136 |   0.0 |  0.00
Modify  | 0.37735    | 0.37735    | 0.37735    |   0.0 |  0.33
Other   |            | 0.05957    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3755 ave        3755 max        3755 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127440 ave      127440 max      127440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127440
Ave neighs/atom = 63.72
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.315845218552, Press = 0.665657376118451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -3654.4531     -3654.4531     -3725.6644     -3725.6644      275.59538      275.59538      41589.453      41589.453      674.5171       674.5171     
     52000  -3655.4567     -3655.4567     -3726.0827     -3726.0827      273.32995      273.32995      41841.03       41841.03      -122.4823      -122.4823     
Loop time of 114.182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.717 hours/ns, 8.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.14     | 113.14     | 113.14     |   0.0 | 99.09
Neigh   | 0.51941    | 0.51941    | 0.51941    |   0.0 |  0.45
Comm    | 0.099913   | 0.099913   | 0.099913   |   0.0 |  0.09
Output  | 0.00017029 | 0.00017029 | 0.00017029 |   0.0 |  0.00
Modify  | 0.36501    | 0.36501    | 0.36501    |   0.0 |  0.32
Other   |            | 0.05916    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3859 ave        3859 max        3859 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126862 ave      126862 max      126862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126862
Ave neighs/atom = 63.431
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.305647999254, Press = 1.95895709398979
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -3655.4567     -3655.4567     -3726.0827     -3726.0827      273.32995      273.32995      41841.03       41841.03      -122.4823      -122.4823     
     53000  -3651.5178     -3651.5178     -3724.3309     -3724.3309      281.79431      281.79431      41898.187      41898.187     -188.40857     -188.40857    
Loop time of 116.321 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.743 ns/day, 32.311 hours/ns, 8.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.24     | 115.24     | 115.24     |   0.0 | 99.07
Neigh   | 0.5346     | 0.5346     | 0.5346     |   0.0 |  0.46
Comm    | 0.10273    | 0.10273    | 0.10273    |   0.0 |  0.09
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.38502    | 0.38502    | 0.38502    |   0.0 |  0.33
Other   |            | 0.06121    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3772 ave        3772 max        3772 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126908 ave      126908 max      126908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126908
Ave neighs/atom = 63.454
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.313014512555, Press = 0.880927302305148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -3651.5178     -3651.5178     -3724.3309     -3724.3309      281.79431      281.79431      41898.187      41898.187     -188.40857     -188.40857    
     54000  -3654.7917     -3654.7917     -3725.9393     -3725.9393      275.34853      275.34853      41704.402      41704.402      210.43581      210.43581    
Loop time of 113.249 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.458 hours/ns, 8.830 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.08
Neigh   | 0.52       | 0.52       | 0.52       |   0.0 |  0.46
Comm    | 0.098928   | 0.098928   | 0.098928   |   0.0 |  0.09
Output  | 0.00017199 | 0.00017199 | 0.00017199 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  0.32
Other   |            | 0.05931    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3837 ave        3837 max        3837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127240 ave      127240 max      127240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127240
Ave neighs/atom = 63.62
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.285872198885, Press = 1.43257869545687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -3654.7917     -3654.7917     -3725.9393     -3725.9393      275.34853      275.34853      41704.402      41704.402      210.43581      210.43581    
     55000  -3654.1232     -3654.1232     -3724.2218     -3724.2218      271.28878      271.28878      41881.498      41881.498     -192.37511     -192.37511    
Loop time of 113.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.414 hours/ns, 8.843 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.08     | 112.08     | 112.08     |   0.0 | 99.11
Neigh   | 0.49555    | 0.49555    | 0.49555    |   0.0 |  0.44
Comm    | 0.098036   | 0.098036   | 0.098036   |   0.0 |  0.09
Output  | 0.00020914 | 0.00020914 | 0.00020914 |   0.0 |  0.00
Modify  | 0.35778    | 0.35778    | 0.35778    |   0.0 |  0.32
Other   |            | 0.05885    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127070 ave      127070 max      127070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127070
Ave neighs/atom = 63.535
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.29667275392, Press = 0.996915658617051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -3654.1232     -3654.1232     -3724.2218     -3724.2218      271.28878      271.28878      41881.498      41881.498     -192.37511     -192.37511    
     56000  -3652.3019     -3652.3019     -3723.7372     -3723.7372      276.4619       276.4619       41542.406      41542.406      908.7505       908.7505     
Loop time of 113.121 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.422 hours/ns, 8.840 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.08     | 112.08     | 112.08     |   0.0 | 99.08
Neigh   | 0.52086    | 0.52086    | 0.52086    |   0.0 |  0.46
Comm    | 0.098825   | 0.098825   | 0.098825   |   0.0 |  0.09
Output  | 0.00021356 | 0.00021356 | 0.00021356 |   0.0 |  0.00
Modify  | 0.35837    | 0.35837    | 0.35837    |   0.0 |  0.32
Other   |            | 0.05933    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3822 ave        3822 max        3822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127662 ave      127662 max      127662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127662
Ave neighs/atom = 63.831
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.266665029465, Press = 0.900595941873308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -3652.3019     -3652.3019     -3723.7372     -3723.7372      276.4619       276.4619       41542.406      41542.406      908.7505       908.7505     
     57000  -3656.6209     -3656.6209     -3725.4381     -3725.4381      266.32943      266.32943      41900.012      41900.012     -448.63458     -448.63458    
Loop time of 113.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.469 hours/ns, 8.827 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.05
Neigh   | 0.55988    | 0.55988    | 0.55988    |   0.0 |  0.49
Comm    | 0.098384   | 0.098384   | 0.098384   |   0.0 |  0.09
Output  | 0.00016796 | 0.00016796 | 0.00016796 |   0.0 |  0.00
Modify  | 0.35835    | 0.35835    | 0.35835    |   0.0 |  0.32
Other   |            | 0.05967    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3863 ave        3863 max        3863 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127120 ave      127120 max      127120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127120
Ave neighs/atom = 63.56
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.274728647142, Press = 1.80034405923676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -3656.6209     -3656.6209     -3725.4381     -3725.4381      266.32943      266.32943      41900.012      41900.012     -448.63458     -448.63458    
     58000  -3654.0852     -3654.0852     -3726.0874     -3726.0874      278.65586      278.65586      41827.138      41827.138     -64.802186     -64.802186    
Loop time of 126.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.097 hours/ns, 7.915 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.17     | 125.17     | 125.17     |   0.0 | 99.06
Neigh   | 0.56301    | 0.56301    | 0.56301    |   0.0 |  0.45
Comm    | 0.11236    | 0.11236    | 0.11236    |   0.0 |  0.09
Output  | 0.00017032 | 0.00017032 | 0.00017032 |   0.0 |  0.00
Modify  | 0.44471    | 0.44471    | 0.44471    |   0.0 |  0.35
Other   |            | 0.06381    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126760 ave      126760 max      126760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126760
Ave neighs/atom = 63.38
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.314462469221, Press = 0.551272059805765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -3654.0852     -3654.0852     -3726.0874     -3726.0874      278.65586      278.65586      41827.138      41827.138     -64.802186     -64.802186    
     59000  -3653.796      -3653.796      -3725.4894     -3725.4894      277.46089      277.46089      41761.952      41761.952      106.86754      106.86754    
Loop time of 114.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.706 hours/ns, 8.761 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.1      | 113.1      | 113.1      |   0.0 | 99.09
Neigh   | 0.52093    | 0.52093    | 0.52093    |   0.0 |  0.46
Comm    | 0.09893    | 0.09893    | 0.09893    |   0.0 |  0.09
Output  | 0.0001669  | 0.0001669  | 0.0001669  |   0.0 |  0.00
Modify  | 0.36475    | 0.36475    | 0.36475    |   0.0 |  0.32
Other   |            | 0.05925    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3831 ave        3831 max        3831 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127362 ave      127362 max      127362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127362
Ave neighs/atom = 63.681
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.333605360366, Press = 1.20965185159584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -3653.796      -3653.796      -3725.4894     -3725.4894      277.46089      277.46089      41761.952      41761.952      106.86754      106.86754    
     60000  -3656.9622     -3656.9622     -3727.835      -3727.835       274.28514      274.28514      41758.791      41758.791      34.975746      34.975746    
Loop time of 113.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.557 hours/ns, 8.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.57     | 112.57     | 112.57     |   0.0 | 99.08
Neigh   | 0.52116    | 0.52116    | 0.52116    |   0.0 |  0.46
Comm    | 0.098488   | 0.098488   | 0.098488   |   0.0 |  0.09
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.3619     | 0.3619     | 0.3619     |   0.0 |  0.32
Other   |            | 0.05918    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3800 ave        3800 max        3800 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127110 ave      127110 max      127110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127110
Ave neighs/atom = 63.555
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.328368116115, Press = 1.33633306577964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -3656.9622     -3656.9622     -3727.835      -3727.835       274.28514      274.28514      41758.791      41758.791      34.975746      34.975746    
     61000  -3653.2129     -3653.2129     -3723.2723     -3723.2723      271.13734      271.13734      41919.879      41919.879     -316.07816     -316.07816    
Loop time of 119.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.326 hours/ns, 8.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.89     | 118.89     | 118.89     |   0.0 | 99.10
Neigh   | 0.52016    | 0.52016    | 0.52016    |   0.0 |  0.43
Comm    | 0.10471    | 0.10471    | 0.10471    |   0.0 |  0.09
Output  | 0.00024656 | 0.00024656 | 0.00024656 |   0.0 |  0.00
Modify  | 0.39856    | 0.39856    | 0.39856    |   0.0 |  0.33
Other   |            | 0.06093    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3806 ave        3806 max        3806 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126936 ave      126936 max      126936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126936
Ave neighs/atom = 63.468
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.291549099374, Press = 0.75369928945099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -3653.2129     -3653.2129     -3723.2723     -3723.2723      271.13734      271.13734      41919.879      41919.879     -316.07816     -316.07816    
     62000  -3653.2889     -3653.2889     -3724.9277     -3724.9277      277.24978      277.24978      41621.181      41621.181      675.45701      675.45701    
Loop time of 117.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.733 ns/day, 32.755 hours/ns, 8.480 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.84     | 116.84     | 116.84     |   0.0 | 99.08
Neigh   | 0.53239    | 0.53239    | 0.53239    |   0.0 |  0.45
Comm    | 0.10344    | 0.10344    | 0.10344    |   0.0 |  0.09
Output  | 0.00020719 | 0.00020719 | 0.00020719 |   0.0 |  0.00
Modify  | 0.38469    | 0.38469    | 0.38469    |   0.0 |  0.33
Other   |            | 0.05894    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3790 ave        3790 max        3790 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127560 ave      127560 max      127560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127560
Ave neighs/atom = 63.78
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.283307631563, Press = 1.23433162402567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -3653.2889     -3653.2889     -3724.9277     -3724.9277      277.24978      277.24978      41621.181      41621.181      675.45701      675.45701    
     63000  -3655.9683     -3655.9683     -3726.7503     -3726.7503      273.93363      273.93363      41966.836      41966.836     -518.63133     -518.63133    
Loop time of 118.845 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.013 hours/ns, 8.414 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.75     | 117.75     | 117.75     |   0.0 | 99.08
Neigh   | 0.5359     | 0.5359     | 0.5359     |   0.0 |  0.45
Comm    | 0.10403    | 0.10403    | 0.10403    |   0.0 |  0.09
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.39401    | 0.39401    | 0.39401    |   0.0 |  0.33
Other   |            | 0.05954    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3807 ave        3807 max        3807 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126666 ave      126666 max      126666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126666
Ave neighs/atom = 63.333
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.274831945941, Press = 1.33564367005755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -3655.9683     -3655.9683     -3726.7503     -3726.7503      273.93363      273.93363      41966.836      41966.836     -518.63133     -518.63133    
     64000  -3655.6421     -3655.6421     -3725.9589     -3725.9589      272.13312      272.13312      41710.23       41710.23       335.65259      335.65259    
Loop time of 112.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.383 hours/ns, 8.851 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.97     | 111.97     | 111.97     |   0.0 | 99.11
Neigh   | 0.49447    | 0.49447    | 0.49447    |   0.0 |  0.44
Comm    | 0.098358   | 0.098358   | 0.098358   |   0.0 |  0.09
Output  | 0.00017098 | 0.00017098 | 0.00017098 |   0.0 |  0.00
Modify  | 0.35669    | 0.35669    | 0.35669    |   0.0 |  0.32
Other   |            | 0.05692    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3869 ave        3869 max        3869 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127338 ave      127338 max      127338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127338
Ave neighs/atom = 63.669
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.28933979409, Press = 0.732159276499092
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -3655.6421     -3655.6421     -3725.9589     -3725.9589      272.13312      272.13312      41710.23       41710.23       335.65259      335.65259    
     65000  -3654.2683     -3654.2683     -3724.6118     -3724.6118      272.23656      272.23656      41855.016      41855.016     -172.70253     -172.70253    
Loop time of 113.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.431 hours/ns, 8.838 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.15     | 112.15     | 112.15     |   0.0 | 99.11
Neigh   | 0.49175    | 0.49175    | 0.49175    |   0.0 |  0.43
Comm    | 0.097344   | 0.097344   | 0.097344   |   0.0 |  0.09
Output  | 0.00021196 | 0.00021196 | 0.00021196 |   0.0 |  0.00
Modify  | 0.35628    | 0.35628    | 0.35628    |   0.0 |  0.31
Other   |            | 0.05867    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3774 ave        3774 max        3774 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127094 ave      127094 max      127094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127094
Ave neighs/atom = 63.547
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.26794999403, Press = 1.09721820656008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -3654.2683     -3654.2683     -3724.6118     -3724.6118      272.23656      272.23656      41855.016      41855.016     -172.70253     -172.70253    
     66000  -3652.7872     -3652.7872     -3723.8625     -3723.8625      275.06876      275.06876      41814.646      41814.646      0.78691801     0.78691801   
Loop time of 112.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.298 hours/ns, 8.875 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.64     | 111.64     | 111.64     |   0.0 | 99.09
Neigh   | 0.51784    | 0.51784    | 0.51784    |   0.0 |  0.46
Comm    | 0.098199   | 0.098199   | 0.098199   |   0.0 |  0.09
Output  | 0.00016941 | 0.00016941 | 0.00016941 |   0.0 |  0.00
Modify  | 0.35642    | 0.35642    | 0.35642    |   0.0 |  0.32
Other   |            | 0.058      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3864 ave        3864 max        3864 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127056 ave      127056 max      127056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127056
Ave neighs/atom = 63.528
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.308292145463, Press = 0.758138915450412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -3652.7872     -3652.7872     -3723.8625     -3723.8625      275.06876      275.06876      41814.646      41814.646      0.78691801     0.78691801   
     67000  -3655.0542     -3655.0542     -3725.0661     -3725.0661      270.95321      270.95321      41802.306      41802.306      29.6957        29.6957      
Loop time of 113.419 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.505 hours/ns, 8.817 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.08
Neigh   | 0.52131    | 0.52131    | 0.52131    |   0.0 |  0.46
Comm    | 0.098824   | 0.098824   | 0.098824   |   0.0 |  0.09
Output  | 0.00016622 | 0.00016622 | 0.00016622 |   0.0 |  0.00
Modify  | 0.35905    | 0.35905    | 0.35905    |   0.0 |  0.32
Other   |            | 0.05868    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3809 ave        3809 max        3809 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127088 ave      127088 max      127088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127088
Ave neighs/atom = 63.544
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.307574267356, Press = 0.771591312448868
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -3655.0542     -3655.0542     -3725.0661     -3725.0661      270.95321      270.95321      41802.306      41802.306      29.6957        29.6957      
     68000  -3650.2739     -3650.2739     -3723.2511     -3723.2511      282.42922      282.42922      41748.312      41748.312      232.05781      232.05781    
Loop time of 124.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.537 hours/ns, 8.043 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.17     | 123.17     | 123.17     |   0.0 | 99.07
Neigh   | 0.56022    | 0.56022    | 0.56022    |   0.0 |  0.45
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.09
Output  | 0.00016818 | 0.00016818 | 0.00016818 |   0.0 |  0.00
Modify  | 0.42809    | 0.42809    | 0.42809    |   0.0 |  0.34
Other   |            | 0.0624     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3843 ave        3843 max        3843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127670 ave      127670 max      127670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127670
Ave neighs/atom = 63.835
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.346689672639, Press = 1.00205850350096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -3650.2739     -3650.2739     -3723.2511     -3723.2511      282.42922      282.42922      41748.312      41748.312      232.05781      232.05781    
     69000  -3656.1688     -3656.1688     -3725.1483     -3725.1483      266.95789      266.95789      41983.363      41983.363     -579.86085     -579.86085    
Loop time of 127.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.338 hours/ns, 7.860 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.03     | 126.03     | 126.03     |   0.0 | 99.07
Neigh   | 0.56569    | 0.56569    | 0.56569    |   0.0 |  0.44
Comm    | 0.11176    | 0.11176    | 0.11176    |   0.0 |  0.09
Output  | 0.00054139 | 0.00054139 | 0.00054139 |   0.0 |  0.00
Modify  | 0.44678    | 0.44678    | 0.44678    |   0.0 |  0.35
Other   |            | 0.0637     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3820 ave        3820 max        3820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126866 ave      126866 max      126866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126866
Ave neighs/atom = 63.433
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.363414183548, Press = 1.09403963058203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -3656.1688     -3656.1688     -3725.1483     -3725.1483      266.95789      266.95789      41983.363      41983.363     -579.86085     -579.86085    
     70000  -3656.1609     -3656.1609     -3726.2882     -3726.2882      271.40001      271.40001      41634.989      41634.989      518.49029      518.49029    
Loop time of 127.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.300 hours/ns, 7.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.92     | 125.92     | 125.92     |   0.0 | 99.09
Neigh   | 0.53824    | 0.53824    | 0.53824    |   0.0 |  0.42
Comm    | 0.11142    | 0.11142    | 0.11142    |   0.0 |  0.09
Output  | 0.00020777 | 0.00020777 | 0.00020777 |   0.0 |  0.00
Modify  | 0.44829    | 0.44829    | 0.44829    |   0.0 |  0.35
Other   |            | 0.06378    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3807 ave        3807 max        3807 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127076 ave      127076 max      127076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127076
Ave neighs/atom = 63.538
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.363036254375, Press = 0.387873221418422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -3656.1609     -3656.1609     -3726.2882     -3726.2882      271.40001      271.40001      41634.989      41634.989      518.49029      518.49029    
     71000  -3655.0259     -3655.0259     -3725.6262     -3725.6262      273.23064      273.23064      41810.226      41810.226      15.705607      15.705607    
Loop time of 127.229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.341 hours/ns, 7.860 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.02     | 126.02     | 126.02     |   0.0 | 99.05
Neigh   | 0.59702    | 0.59702    | 0.59702    |   0.0 |  0.47
Comm    | 0.11231    | 0.11231    | 0.11231    |   0.0 |  0.09
Output  | 0.00023458 | 0.00023458 | 0.00023458 |   0.0 |  0.00
Modify  | 0.43958    | 0.43958    | 0.43958    |   0.0 |  0.35
Other   |            | 0.06364    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3844 ave        3844 max        3844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127066 ave      127066 max      127066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127066
Ave neighs/atom = 63.533
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37316424647, Press = 1.10125015398736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -3655.0259     -3655.0259     -3725.6262     -3725.6262      273.23064      273.23064      41810.226      41810.226      15.705607      15.705607    
     72000  -3653.5923     -3653.5923     -3724.425      -3724.425       274.12985      274.12985      41812.474      41812.474      65.337123      65.337123    
Loop time of 127.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.299 hours/ns, 7.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.92     | 125.92     | 125.92     |   0.0 | 99.09
Neigh   | 0.53495    | 0.53495    | 0.53495    |   0.0 |  0.42
Comm    | 0.11222    | 0.11222    | 0.11222    |   0.0 |  0.09
Output  | 0.0001679  | 0.0001679  | 0.0001679  |   0.0 |  0.00
Modify  | 0.44598    | 0.44598    | 0.44598    |   0.0 |  0.35
Other   |            | 0.06437    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3768 ave        3768 max        3768 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127180 ave      127180 max      127180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127180
Ave neighs/atom = 63.59
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.342195776889, Press = 0.771214948482937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -3653.5923     -3653.5923     -3724.425      -3724.425       274.12985      274.12985      41812.474      41812.474      65.337123      65.337123    
     73000  -3653.9065     -3653.9065     -3725.0798     -3725.0798      275.44804      275.44804      41800.197      41800.197      62.05444       62.05444     
Loop time of 126.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.270 hours/ns, 7.876 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.83     | 125.83     | 125.83     |   0.0 | 99.10
Neigh   | 0.53454    | 0.53454    | 0.53454    |   0.0 |  0.42
Comm    | 0.11083    | 0.11083    | 0.11083    |   0.0 |  0.09
Output  | 0.00016811 | 0.00016811 | 0.00016811 |   0.0 |  0.00
Modify  | 0.43879    | 0.43879    | 0.43879    |   0.0 |  0.35
Other   |            | 0.06382    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3820 ave        3820 max        3820 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127220 ave      127220 max      127220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127220
Ave neighs/atom = 63.61
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.318345289157, Press = 0.822278494498364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -3653.9065     -3653.9065     -3725.0798     -3725.0798      275.44804      275.44804      41800.197      41800.197      62.05444       62.05444     
     74000  -3652.6674     -3652.6674     -3723.334      -3723.334       273.48693      273.48693      41943.561      41943.561     -357.82344     -357.82344    
Loop time of 126.884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.246 hours/ns, 7.881 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.73     | 125.73     | 125.73     |   0.0 | 99.09
Neigh   | 0.532      | 0.532      | 0.532      |   0.0 |  0.42
Comm    | 0.11079    | 0.11079    | 0.11079    |   0.0 |  0.09
Output  | 0.0001689  | 0.0001689  | 0.0001689  |   0.0 |  0.00
Modify  | 0.44732    | 0.44732    | 0.44732    |   0.0 |  0.35
Other   |            | 0.06393    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3793 ave        3793 max        3793 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126662 ave      126662 max      126662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126662
Ave neighs/atom = 63.331
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.295073093589, Press = 0.764057215214184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -3652.6674     -3652.6674     -3723.334      -3723.334       273.48693      273.48693      41943.561      41943.561     -357.82344     -357.82344    
     75000  -3654.4479     -3654.4479     -3725.5478     -3725.5478      275.16377      275.16377      41723.627      41723.627      308.04484      308.04484    
Loop time of 126.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.063 hours/ns, 7.922 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.04     | 125.04     | 125.04     |   0.0 | 99.06
Neigh   | 0.56121    | 0.56121    | 0.56121    |   0.0 |  0.44
Comm    | 0.11204    | 0.11204    | 0.11204    |   0.0 |  0.09
Output  | 0.00020483 | 0.00020483 | 0.00020483 |   0.0 |  0.00
Modify  | 0.4493     | 0.4493     | 0.4493     |   0.0 |  0.36
Other   |            | 0.06388    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3849 ave        3849 max        3849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127076 ave      127076 max      127076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127076
Ave neighs/atom = 63.538
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.32937384013, Press = 0.336805021783125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -3654.4479     -3654.4479     -3725.5478     -3725.5478      275.16377      275.16377      41723.627      41723.627      308.04484      308.04484    
     76000  -3654.7456     -3654.7456     -3723.5886     -3723.5886      266.42926      266.42926      41831.833      41831.833     -157.55522     -157.55522    
Loop time of 126.606 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.168 hours/ns, 7.899 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.42     | 125.42     | 125.42     |   0.0 | 99.06
Neigh   | 0.56053    | 0.56053    | 0.56053    |   0.0 |  0.44
Comm    | 0.11279    | 0.11279    | 0.11279    |   0.0 |  0.09
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.44785    | 0.44785    | 0.44785    |   0.0 |  0.35
Other   |            | 0.06339    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3849 ave        3849 max        3849 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127446 ave      127446 max      127446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127446
Ave neighs/atom = 63.723
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.320845762971, Press = 1.37848914437077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -3654.7456     -3654.7456     -3723.5886     -3723.5886      266.42926      266.42926      41831.833      41831.833     -157.55522     -157.55522    
     77000  -3651.1273     -3651.1273     -3724.1774     -3724.1774      282.71148      282.71148      41944.44       41944.44      -297.1176      -297.1176     
Loop time of 126.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.064 hours/ns, 7.922 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.02     | 125.02     | 125.02     |   0.0 | 99.04
Neigh   | 0.58641    | 0.58641    | 0.58641    |   0.0 |  0.46
Comm    | 0.11108    | 0.11108    | 0.11108    |   0.0 |  0.09
Output  | 0.00020407 | 0.00020407 | 0.00020407 |   0.0 |  0.00
Modify  | 0.44887    | 0.44887    | 0.44887    |   0.0 |  0.36
Other   |            | 0.06379    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126798 ave      126798 max      126798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126798
Ave neighs/atom = 63.399
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.34976234769, Press = 0.284548227258628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -3651.1273     -3651.1273     -3724.1774     -3724.1774      282.71148      282.71148      41944.44       41944.44      -297.1176      -297.1176     
     78000  -3653.7631     -3653.7631     -3725.6249     -3725.6249      278.11236      278.11236      41733.683      41733.683      175.49241      175.49241    
Loop time of 126.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.219 hours/ns, 7.887 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.6      | 125.6      | 125.6      |   0.0 | 99.06
Neigh   | 0.56344    | 0.56344    | 0.56344    |   0.0 |  0.44
Comm    | 0.11259    | 0.11259    | 0.11259    |   0.0 |  0.09
Output  | 0.00016807 | 0.00016807 | 0.00016807 |   0.0 |  0.00
Modify  | 0.44823    | 0.44823    | 0.44823    |   0.0 |  0.35
Other   |            | 0.06455    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3860 ave        3860 max        3860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127198 ave      127198 max      127198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127198
Ave neighs/atom = 63.599
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.360308873895, Press = 0.78565047007836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -3653.7631     -3653.7631     -3725.6249     -3725.6249      278.11236      278.11236      41733.683      41733.683      175.49241      175.49241    
     79000  -3656.3778     -3656.3778     -3724.3917     -3724.3917      263.22062      263.22062      41814.933      41814.933      15.164713      15.164713    
Loop time of 123.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.441 hours/ns, 8.065 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.83     | 122.83     | 122.83     |   0.0 | 99.07
Neigh   | 0.55123    | 0.55123    | 0.55123    |   0.0 |  0.44
Comm    | 0.10955    | 0.10955    | 0.10955    |   0.0 |  0.09
Output  | 0.00020486 | 0.00020486 | 0.00020486 |   0.0 |  0.00
Modify  | 0.43059    | 0.43059    | 0.43059    |   0.0 |  0.35
Other   |            | 0.06268    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3782 ave        3782 max        3782 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126876 ave      126876 max      126876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126876
Ave neighs/atom = 63.438
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.351208296802, Press = 0.734653549946598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -3656.3778     -3656.3778     -3724.3917     -3724.3917      263.22062      263.22062      41814.933      41814.933      15.164713      15.164713    
     80000  -3653.1007     -3653.1007     -3724.0417     -3724.0417      274.54913      274.54913      41769.753      41769.753      90.767297      90.767297    
Loop time of 126.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.116 hours/ns, 7.910 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.25     | 125.25     | 125.25     |   0.0 | 99.08
Neigh   | 0.53415    | 0.53415    | 0.53415    |   0.0 |  0.42
Comm    | 0.11275    | 0.11275    | 0.11275    |   0.0 |  0.09
Output  | 0.00016739 | 0.00016739 | 0.00016739 |   0.0 |  0.00
Modify  | 0.45062    | 0.45062    | 0.45062    |   0.0 |  0.36
Other   |            | 0.06429    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3785 ave        3785 max        3785 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127312 ave      127312 max      127312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127312
Ave neighs/atom = 63.656
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.365810518315, Press = 0.501766787869952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -3653.1007     -3653.1007     -3724.0417     -3724.0417      274.54913      274.54913      41769.753      41769.753      90.767297      90.767297    
     81000  -3654.7138     -3654.7138     -3724.6255     -3724.6255      270.56551      270.56551      41810.258      41810.258     -50.936007     -50.936007    
Loop time of 126.722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.201 hours/ns, 7.891 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.54     | 125.54     | 125.54     |   0.0 | 99.07
Neigh   | 0.55717    | 0.55717    | 0.55717    |   0.0 |  0.44
Comm    | 0.11195    | 0.11195    | 0.11195    |   0.0 |  0.09
Output  | 0.00020478 | 0.00020478 | 0.00020478 |   0.0 |  0.00
Modify  | 0.45065    | 0.45065    | 0.45065    |   0.0 |  0.36
Other   |            | 0.06342    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3841 ave        3841 max        3841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127200 ave      127200 max      127200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127200
Ave neighs/atom = 63.6
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.375999480432, Press = 1.15386954826019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -3654.7138     -3654.7138     -3724.6255     -3724.6255      270.56551      270.56551      41810.258      41810.258     -50.936007     -50.936007    
     82000  -3653.3436     -3653.3436     -3724.9281     -3724.9281      277.03935      277.03935      41896.221      41896.221     -323.93427     -323.93427    
Loop time of 126.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.096 hours/ns, 7.915 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.18     | 125.18     | 125.18     |   0.0 | 99.08
Neigh   | 0.55731    | 0.55731    | 0.55731    |   0.0 |  0.44
Comm    | 0.10983    | 0.10983    | 0.10983    |   0.0 |  0.09
Output  | 0.00016958 | 0.00016958 | 0.00016958 |   0.0 |  0.00
Modify  | 0.43768    | 0.43768    | 0.43768    |   0.0 |  0.35
Other   |            | 0.06227    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3798 ave        3798 max        3798 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126906 ave      126906 max      126906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126906
Ave neighs/atom = 63.453
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.405327460621, Press = 0.318818942750425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -3653.3436     -3653.3436     -3724.9281     -3724.9281      277.03935      277.03935      41896.221      41896.221     -323.93427     -323.93427    
     83000  -3653.6213     -3653.6213     -3724.2678     -3724.2678      273.40942      273.40942      41674.032      41674.032      437.69431      437.69431    
Loop time of 126.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.200 hours/ns, 7.891 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.54     | 125.54     | 125.54     |   0.0 | 99.07
Neigh   | 0.55853    | 0.55853    | 0.55853    |   0.0 |  0.44
Comm    | 0.11079    | 0.11079    | 0.11079    |   0.0 |  0.09
Output  | 0.00020348 | 0.00020348 | 0.00020348 |   0.0 |  0.00
Modify  | 0.44332    | 0.44332    | 0.44332    |   0.0 |  0.35
Other   |            | 0.0635     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3824 ave        3824 max        3824 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127328 ave      127328 max      127328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127328
Ave neighs/atom = 63.664
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.415484531739, Press = 0.755014371588482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -3653.6213     -3653.6213     -3724.2678     -3724.2678      273.40942      273.40942      41674.032      41674.032      437.69431      437.69431    
     84000  -3653.847      -3653.847      -3725.7426     -3725.7426      278.24362      278.24362      41891.408      41891.408     -334.77598     -334.77598    
Loop time of 126.516 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.683 ns/day, 35.143 hours/ns, 7.904 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.33     | 125.33     | 125.33     |   0.0 | 99.06
Neigh   | 0.56413    | 0.56413    | 0.56413    |   0.0 |  0.45
Comm    | 0.11244    | 0.11244    | 0.11244    |   0.0 |  0.09
Output  | 0.00016894 | 0.00016894 | 0.00016894 |   0.0 |  0.00
Modify  | 0.4504     | 0.4504     | 0.4504     |   0.0 |  0.36
Other   |            | 0.06328    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3821 ave        3821 max        3821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126974 ave      126974 max      126974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126974
Ave neighs/atom = 63.487
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.446690556693, Press = 0.873208990909285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -3653.847      -3653.847      -3725.7426     -3725.7426      278.24362      278.24362      41891.408      41891.408     -334.77598     -334.77598    
     85000  -3655.6245     -3655.6245     -3724.9359     -3724.9359      268.24225      268.24225      41660.324      41660.324      440.62973      440.62973    
Loop time of 124.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.473 hours/ns, 8.058 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.94     | 122.94     | 122.94     |   0.0 | 99.06
Neigh   | 0.55722    | 0.55722    | 0.55722    |   0.0 |  0.45
Comm    | 0.1102     | 0.1102     | 0.1102     |   0.0 |  0.09
Output  | 0.00016748 | 0.00016748 | 0.00016748 |   0.0 |  0.00
Modify  | 0.43305    | 0.43305    | 0.43305    |   0.0 |  0.35
Other   |            | 0.0628     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3857 ave        3857 max        3857 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127494 ave      127494 max      127494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127494
Ave neighs/atom = 63.747
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.437783363384, Press = 0.153404563733667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -3655.6245     -3655.6245     -3724.9359     -3724.9359      268.24225      268.24225      41660.324      41660.324      440.62973      440.62973    
     86000  -3655.1264     -3655.1264     -3723.3347     -3723.3347      263.97299      263.97299      41817.081      41817.081     -150.89114     -150.89114    
Loop time of 113.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.482 hours/ns, 8.823 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.28     | 112.28     | 112.28     |   0.0 | 99.07
Neigh   | 0.5438     | 0.5438     | 0.5438     |   0.0 |  0.48
Comm    | 0.099602   | 0.099602   | 0.099602   |   0.0 |  0.09
Output  | 0.00020908 | 0.00020908 | 0.00020908 |   0.0 |  0.00
Modify  | 0.35696    | 0.35696    | 0.35696    |   0.0 |  0.31
Other   |            | 0.05693    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127400 ave      127400 max      127400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127400
Ave neighs/atom = 63.7
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.421676525287, Press = 1.5240439603197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -3655.1264     -3655.1264     -3723.3347     -3723.3347      263.97299      263.97299      41817.081      41817.081     -150.89114     -150.89114    
     87000  -3649.7092     -3649.7092     -3720.3261     -3720.3261      273.29477      273.29477      41881.447      41881.447     -54.373375     -54.373375    
Loop time of 112.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.333 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.77     | 111.77     | 111.77     |   0.0 | 99.08
Neigh   | 0.51882    | 0.51882    | 0.51882    |   0.0 |  0.46
Comm    | 0.098289   | 0.098289   | 0.098289   |   0.0 |  0.09
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.35829    | 0.35829    | 0.35829    |   0.0 |  0.32
Other   |            | 0.05703    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3768 ave        3768 max        3768 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127130 ave      127130 max      127130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127130
Ave neighs/atom = 63.565
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.430534609526, Press = 0.527562873998252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -3649.7092     -3649.7092     -3720.3261     -3720.3261      273.29477      273.29477      41881.447      41881.447     -54.373375     -54.373375    
     88000  -3654.956      -3654.956      -3724.7972     -3724.7972      270.29231      270.29231      41738.26       41738.26       167.29952      167.29952    
Loop time of 112.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.320 hours/ns, 8.869 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.72     | 111.72     | 111.72     |   0.0 | 99.08
Neigh   | 0.51858    | 0.51858    | 0.51858    |   0.0 |  0.46
Comm    | 0.09897    | 0.09897    | 0.09897    |   0.0 |  0.09
Output  | 0.00017177 | 0.00017177 | 0.00017177 |   0.0 |  0.00
Modify  | 0.35783    | 0.35783    | 0.35783    |   0.0 |  0.32
Other   |            | 0.05694    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3845 ave        3845 max        3845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127262 ave      127262 max      127262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127262
Ave neighs/atom = 63.631
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45607342093, Press = 0.615966414082824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -3654.956      -3654.956      -3724.7972     -3724.7972      270.29231      270.29231      41738.26       41738.26       167.29952      167.29952    
     89000  -3651.8771     -3651.8771     -3723.612      -3723.612       277.62176      277.62176      41914.491      41914.491     -197.14207     -197.14207    
Loop time of 113.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.390 hours/ns, 8.849 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.97     | 111.97     | 111.97     |   0.0 | 99.09
Neigh   | 0.51938    | 0.51938    | 0.51938    |   0.0 |  0.46
Comm    | 0.099263   | 0.099263   | 0.099263   |   0.0 |  0.09
Output  | 0.00016865 | 0.00016865 | 0.00016865 |   0.0 |  0.00
Modify  | 0.3576     | 0.3576     | 0.3576     |   0.0 |  0.32
Other   |            | 0.05706    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3781 ave        3781 max        3781 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126836 ave      126836 max      126836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126836
Ave neighs/atom = 63.418
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.453203512453, Press = 0.720724935229463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -3651.8771     -3651.8771     -3723.612      -3723.612       277.62176      277.62176      41914.491      41914.491     -197.14207     -197.14207    
     90000  -3654.4531     -3654.4531     -3725.1957     -3725.1957      273.78103      273.78103      41830.786      41830.786     -39.898851     -39.898851    
Loop time of 112.884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.357 hours/ns, 8.859 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.88     | 111.88     | 111.88     |   0.0 | 99.11
Neigh   | 0.49313    | 0.49313    | 0.49313    |   0.0 |  0.44
Comm    | 0.098803   | 0.098803   | 0.098803   |   0.0 |  0.09
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35733    | 0.35733    | 0.35733    |   0.0 |  0.32
Other   |            | 0.05733    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3821 ave        3821 max        3821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126968 ave      126968 max      126968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126968
Ave neighs/atom = 63.484
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451183126364, Press = 0.375015020172828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -3654.4531     -3654.4531     -3725.1957     -3725.1957      273.78103      273.78103      41830.786      41830.786     -39.898851     -39.898851    
     91000  -3653.4765     -3653.4765     -3725.2773     -3725.2773      277.87634      277.87634      41611.051      41611.051      662.26948      662.26948    
Loop time of 112.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.386 hours/ns, 8.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.96     | 111.96     | 111.96     |   0.0 | 99.09
Neigh   | 0.51904    | 0.51904    | 0.51904    |   0.0 |  0.46
Comm    | 0.098725   | 0.098725   | 0.098725   |   0.0 |  0.09
Output  | 0.00016924 | 0.00016924 | 0.00016924 |   0.0 |  0.00
Modify  | 0.35809    | 0.35809    | 0.35809    |   0.0 |  0.32
Other   |            | 0.0567     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3774 ave        3774 max        3774 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127770 ave      127770 max      127770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127770
Ave neighs/atom = 63.885
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463179250471, Press = 0.901964625403752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -3653.4765     -3653.4765     -3725.2773     -3725.2773      277.87634      277.87634      41611.051      41611.051      662.26948      662.26948    
     92000  -3653.2982     -3653.2982     -3724.3779     -3724.3779      275.08581      275.08581      41973.827      41973.827     -511.44338     -511.44338    
Loop time of 112.991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.386 hours/ns, 8.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.96     | 111.96     | 111.96     |   0.0 | 99.09
Neigh   | 0.51864    | 0.51864    | 0.51864    |   0.0 |  0.46
Comm    | 0.099376   | 0.099376   | 0.099376   |   0.0 |  0.09
Output  | 0.00016878 | 0.00016878 | 0.00016878 |   0.0 |  0.00
Modify  | 0.35779    | 0.35779    | 0.35779    |   0.0 |  0.32
Other   |            | 0.05704    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3797 ave        3797 max        3797 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126766 ave      126766 max      126766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126766
Ave neighs/atom = 63.383
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454973463917, Press = 0.667477618835022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -3653.2982     -3653.2982     -3724.3779     -3724.3779      275.08581      275.08581      41973.827      41973.827     -511.44338     -511.44338    
     93000  -3656.5353     -3656.5353     -3727.0013     -3727.0013      272.71079      272.71079      41651.992      41651.992      439.14483      439.14483    
Loop time of 113.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.436 hours/ns, 8.836 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.14     | 112.14     | 112.14     |   0.0 | 99.09
Neigh   | 0.52008    | 0.52008    | 0.52008    |   0.0 |  0.46
Comm    | 0.098941   | 0.098941   | 0.098941   |   0.0 |  0.09
Output  | 0.00016864 | 0.00016864 | 0.00016864 |   0.0 |  0.00
Modify  | 0.35819    | 0.35819    | 0.35819    |   0.0 |  0.32
Other   |            | 0.0568     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3842 ave        3842 max        3842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127174 ave      127174 max      127174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127174
Ave neighs/atom = 63.587
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.456012552302, Press = 0.614170580731701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -3656.5353     -3656.5353     -3727.0013     -3727.0013      272.71079      272.71079      41651.992      41651.992      439.14483      439.14483    
     94000  -3651.1612     -3651.1612     -3721.6659     -3721.6659      272.86047      272.86047      41871.783      41871.783     -114.98162     -114.98162    
Loop time of 113.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.427 hours/ns, 8.839 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.1      | 112.1      | 112.1      |   0.0 | 99.09
Neigh   | 0.51971    | 0.51971    | 0.51971    |   0.0 |  0.46
Comm    | 0.098857   | 0.098857   | 0.098857   |   0.0 |  0.09
Output  | 0.00021543 | 0.00021543 | 0.00021543 |   0.0 |  0.00
Modify  | 0.35785    | 0.35785    | 0.35785    |   0.0 |  0.32
Other   |            | 0.05695    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127084 ave      127084 max      127084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127084
Ave neighs/atom = 63.542
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.473059784318, Press = 0.952227825611308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -3651.1612     -3651.1612     -3721.6659     -3721.6659      272.86047      272.86047      41871.783      41871.783     -114.98162     -114.98162    
     95000  -3654.8845     -3654.8845     -3725.169      -3725.169       272.00847      272.00847      41831.829      41831.829     -131.20418     -131.20418    
Loop time of 112.764 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.323 hours/ns, 8.868 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.73     | 111.73     | 111.73     |   0.0 | 99.08
Neigh   | 0.51849    | 0.51849    | 0.51849    |   0.0 |  0.46
Comm    | 0.098845   | 0.098845   | 0.098845   |   0.0 |  0.09
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.35655    | 0.35655    | 0.35655    |   0.0 |  0.32
Other   |            | 0.05793    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3830 ave        3830 max        3830 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127012 ave      127012 max      127012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127012
Ave neighs/atom = 63.506
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.481445489225, Press = 0.576641166714609
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -3654.8845     -3654.8845     -3725.169      -3725.169       272.00847      272.00847      41831.829      41831.829     -131.20418     -131.20418    
     96000  -3653.503      -3653.503      -3723.9693     -3723.9693      272.71176      272.71176      41746.228      41746.228      211.70359      211.70359    
Loop time of 112.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.259 hours/ns, 8.886 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.5      | 111.5      | 111.5      |   0.0 | 99.08
Neigh   | 0.51753    | 0.51753    | 0.51753    |   0.0 |  0.46
Comm    | 0.098982   | 0.098982   | 0.098982   |   0.0 |  0.09
Output  | 0.0001687  | 0.0001687  | 0.0001687  |   0.0 |  0.00
Modify  | 0.35497    | 0.35497    | 0.35497    |   0.0 |  0.32
Other   |            | 0.05809    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127478 ave      127478 max      127478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127478
Ave neighs/atom = 63.739
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.495312788223, Press = 0.5065393800015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -3653.503      -3653.503      -3723.9693     -3723.9693      272.71176      272.71176      41746.228      41746.228      211.70359      211.70359    
     97000  -3657.1403     -3657.1403     -3726.4939     -3726.4939      268.40573      268.40573      41810.751      41810.751     -82.675897     -82.675897    
Loop time of 112.91 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.364 hours/ns, 8.857 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.9      | 111.9      | 111.9      |   0.0 | 99.11
Neigh   | 0.49322    | 0.49322    | 0.49322    |   0.0 |  0.44
Comm    | 0.098196   | 0.098196   | 0.098196   |   0.0 |  0.09
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.35682    | 0.35682    | 0.35682    |   0.0 |  0.32
Other   |            | 0.05763    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3850 ave        3850 max        3850 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127178 ave      127178 max      127178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127178
Ave neighs/atom = 63.589
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.483091416784, Press = 0.773236595307775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -3657.1403     -3657.1403     -3726.4939     -3726.4939      268.40573      268.40573      41810.751      41810.751     -82.675897     -82.675897    
     98000  -3653.767      -3653.767      -3723.9142     -3723.9142      271.47667      271.47667      41810.852      41810.852      17.82586       17.82586     
Loop time of 113.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.461 hours/ns, 8.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.22     | 112.22     | 112.22     |   0.0 | 99.08
Neigh   | 0.52125    | 0.52125    | 0.52125    |   0.0 |  0.46
Comm    | 0.099768   | 0.099768   | 0.099768   |   0.0 |  0.09
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.36235    | 0.36235    | 0.36235    |   0.0 |  0.32
Other   |            | 0.05766    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3808 ave        3808 max        3808 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127262 ave      127262 max      127262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127262
Ave neighs/atom = 63.631
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.461507286236, Press = 0.422003669312825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -3653.767      -3653.767      -3723.9142     -3723.9142      271.47667      271.47667      41810.852      41810.852      17.82586       17.82586     
     99000  -3661.1038     -3661.1038     -3728.3777     -3728.3777      260.35701      260.35701      41685.078      41685.078      228.28395      228.28395    
Loop time of 123.544 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.318 hours/ns, 8.094 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.42     | 122.42     | 122.42     |   0.0 | 99.09
Neigh   | 0.52811    | 0.52811    | 0.52811    |   0.0 |  0.43
Comm    | 0.10893    | 0.10893    | 0.10893    |   0.0 |  0.09
Output  | 0.00021523 | 0.00021523 | 0.00021523 |   0.0 |  0.00
Modify  | 0.42543    | 0.42543    | 0.42543    |   0.0 |  0.34
Other   |            | 0.06127    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3874 ave        3874 max        3874 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127090 ave      127090 max      127090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127090
Ave neighs/atom = 63.545
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.43412469485, Press = 0.84623998722569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -3661.1038     -3661.1038     -3728.3777     -3728.3777      260.35701      260.35701      41685.078      41685.078      228.28395      228.28395    
    100000  -3652.8594     -3652.8594     -3724.1779     -3724.1779      276.01025      276.01025      42050.876      42050.876     -686.08511     -686.08511    
Loop time of 122.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.707 ns/day, 33.937 hours/ns, 8.185 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.04     | 121.04     | 121.04     |   0.0 | 99.07
Neigh   | 0.5438     | 0.5438     | 0.5438     |   0.0 |  0.45
Comm    | 0.10694    | 0.10694    | 0.10694    |   0.0 |  0.09
Output  | 0.00016886 | 0.00016886 | 0.00016886 |   0.0 |  0.00
Modify  | 0.42096    | 0.42096    | 0.42096    |   0.0 |  0.34
Other   |            | 0.06236    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3754 ave        3754 max        3754 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126622 ave      126622 max      126622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126622
Ave neighs/atom = 63.311
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.41447508309, Press = 0.541499787019055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -3652.8594     -3652.8594     -3724.1779     -3724.1779      276.01025      276.01025      42050.876      42050.876     -686.08511     -686.08511    
    101000  -3656.0085     -3656.0085     -3724.5616     -3724.5616      265.30752      265.30752      41654.722      41654.722      457.14136      457.14136    
Loop time of 126.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.229 hours/ns, 7.885 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.65     | 125.65     | 125.65     |   0.0 | 99.07
Neigh   | 0.55715    | 0.55715    | 0.55715    |   0.0 |  0.44
Comm    | 0.11037    | 0.11037    | 0.11037    |   0.0 |  0.09
Output  | 0.00021908 | 0.00021908 | 0.00021908 |   0.0 |  0.00
Modify  | 0.44263    | 0.44263    | 0.44263    |   0.0 |  0.35
Other   |            | 0.06427    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3873 ave        3873 max        3873 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127232 ave      127232 max      127232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127232
Ave neighs/atom = 63.616
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.397881553569, Press = 0.301342415515459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -3656.0085     -3656.0085     -3724.5616     -3724.5616      265.30752      265.30752      41654.722      41654.722      457.14136      457.14136    
    102000  -3655.0857     -3655.0857     -3725.4426     -3725.4426      272.28825      272.28825      41772.969      41772.969      81.432038      81.432038    
Loop time of 127.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.315 hours/ns, 7.866 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.94     | 125.94     | 125.94     |   0.0 | 99.06
Neigh   | 0.5584     | 0.5584     | 0.5584     |   0.0 |  0.44
Comm    | 0.11285    | 0.11285    | 0.11285    |   0.0 |  0.09
Output  | 0.0002088  | 0.0002088  | 0.0002088  |   0.0 |  0.00
Modify  | 0.45684    | 0.45684    | 0.45684    |   0.0 |  0.36
Other   |            | 0.06571    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3846 ave        3846 max        3846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126892 ave      126892 max      126892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126892
Ave neighs/atom = 63.446
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37132146144, Press = 0.806331719264651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -3655.0857     -3655.0857     -3725.4426     -3725.4426      272.28825      272.28825      41772.969      41772.969      81.432038      81.432038    
    103000  -3656.4791     -3656.4791     -3726.6065     -3726.6065      271.40036      271.40036      41797.35       41797.35      -18.463749     -18.463749    
Loop time of 126.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.214 hours/ns, 7.888 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.62     | 125.62     | 125.62     |   0.0 | 99.09
Neigh   | 0.53362    | 0.53362    | 0.53362    |   0.0 |  0.42
Comm    | 0.11135    | 0.11135    | 0.11135    |   0.0 |  0.09
Output  | 0.0001704  | 0.0001704  | 0.0001704  |   0.0 |  0.00
Modify  | 0.43951    | 0.43951    | 0.43951    |   0.0 |  0.35
Other   |            | 0.06422    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3833 ave        3833 max        3833 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127072 ave      127072 max      127072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127072
Ave neighs/atom = 63.536
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.362258367067, Press = 0.470332063380897
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -3656.4791     -3656.4791     -3726.6065     -3726.6065      271.40036      271.40036      41797.35       41797.35      -18.463749     -18.463749    
    104000  -3653.4183     -3653.4183     -3724.1497     -3724.1497      273.7379       273.7379       41786.076      41786.076      66.00012       66.00012     
Loop time of 126.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.262 hours/ns, 7.878 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.79     | 125.79     | 125.79     |   0.0 | 99.09
Neigh   | 0.5348     | 0.5348     | 0.5348     |   0.0 |  0.42
Comm    | 0.11149    | 0.11149    | 0.11149    |   0.0 |  0.09
Output  | 0.00020617 | 0.00020617 | 0.00020617 |   0.0 |  0.00
Modify  | 0.44622    | 0.44622    | 0.44622    |   0.0 |  0.35
Other   |            | 0.06454    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3801 ave        3801 max        3801 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127216 ave      127216 max      127216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127216
Ave neighs/atom = 63.608
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.342538078894, Press = 0.67988017300001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -3653.4183     -3653.4183     -3724.1497     -3724.1497      273.7379       273.7379       41786.076      41786.076      66.00012       66.00012     
    105000  -3656.6872     -3656.6872     -3726.9412     -3726.9412      271.89046      271.89046      41773.299      41773.299     -27.298307     -27.298307    
Loop time of 126.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.170 hours/ns, 7.898 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.43     | 125.43     | 125.43     |   0.0 | 99.06
Neigh   | 0.56429    | 0.56429    | 0.56429    |   0.0 |  0.45
Comm    | 0.1111     | 0.1111     | 0.1111     |   0.0 |  0.09
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.44506    | 0.44506    | 0.44506    |   0.0 |  0.35
Other   |            | 0.06431    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3822 ave        3822 max        3822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127020 ave      127020 max      127020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127020
Ave neighs/atom = 63.51
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.344528423876, Press = 0.545398389387757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -3656.6872     -3656.6872     -3726.9412     -3726.9412      271.89046      271.89046      41773.299      41773.299     -27.298307     -27.298307    
    106000  -3653.7675     -3653.7675     -3724.4425     -3724.4425      273.51945      273.51945      41767.813      41767.813      96.914239      96.914239    
Loop time of 125.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.836 hours/ns, 7.974 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.25     | 124.25     | 124.25     |   0.0 | 99.08
Neigh   | 0.53901    | 0.53901    | 0.53901    |   0.0 |  0.43
Comm    | 0.11111    | 0.11111    | 0.11111    |   0.0 |  0.09
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.44126    | 0.44126    | 0.44126    |   0.0 |  0.35
Other   |            | 0.06376    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3844 ave        3844 max        3844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127182 ave      127182 max      127182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127182
Ave neighs/atom = 63.591
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.352297867375, Press = 0.496597070327166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -3653.7675     -3653.7675     -3724.4425     -3724.4425      273.51945      273.51945      41767.813      41767.813      96.914239      96.914239    
    107000  -3652.5334     -3652.5334     -3724.7278     -3724.7278      279.39965      279.39965      41816.161      41816.161      79.641336      79.641336    
Loop time of 112.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.265 hours/ns, 8.885 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.55     | 111.55     | 111.55     |   0.0 | 99.11
Neigh   | 0.49336    | 0.49336    | 0.49336    |   0.0 |  0.44
Comm    | 0.09821    | 0.09821    | 0.09821    |   0.0 |  0.09
Output  | 0.00017023 | 0.00017023 | 0.00017023 |   0.0 |  0.00
Modify  | 0.35603    | 0.35603    | 0.35603    |   0.0 |  0.32
Other   |            | 0.05791    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3803 ave        3803 max        3803 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127142 ave      127142 max      127142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127142
Ave neighs/atom = 63.571
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.35029095846, Press = 0.557285041712587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -3652.5334     -3652.5334     -3724.7278     -3724.7278      279.39965      279.39965      41816.161      41816.161      79.641336      79.641336    
    108000  -3655.2518     -3655.2518     -3725.781      -3725.781       272.95518      272.95518      41787.55       41787.55       102.37213      102.37213    
Loop time of 123.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.271 hours/ns, 8.105 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.25     | 122.25     | 122.25     |   0.0 | 99.09
Neigh   | 0.53143    | 0.53143    | 0.53143    |   0.0 |  0.43
Comm    | 0.10757    | 0.10757    | 0.10757    |   0.0 |  0.09
Output  | 0.00026455 | 0.00026455 | 0.00026455 |   0.0 |  0.00
Modify  | 0.4263     | 0.4263     | 0.4263     |   0.0 |  0.35
Other   |            | 0.06253    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3765 ave        3765 max        3765 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126788 ave      126788 max      126788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126788
Ave neighs/atom = 63.394
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.366513766814, Press = 0.249561771622072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -3655.2518     -3655.2518     -3725.781      -3725.781       272.95518      272.95518      41787.55       41787.55       102.37213      102.37213    
    109000  -3653.6772     -3653.6772     -3724.3048     -3724.3048      273.33601      273.33601      41646.717      41646.717      573.32822      573.32822    
Loop time of 126.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.268 hours/ns, 7.876 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.78     | 125.78     | 125.78     |   0.0 | 99.07
Neigh   | 0.55851    | 0.55851    | 0.55851    |   0.0 |  0.44
Comm    | 0.1126     | 0.1126     | 0.1126     |   0.0 |  0.09
Output  | 0.00020512 | 0.00020512 | 0.00020512 |   0.0 |  0.00
Modify  | 0.44979    | 0.44979    | 0.44979    |   0.0 |  0.35
Other   |            | 0.06399    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3845 ave        3845 max        3845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127274 ave      127274 max      127274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127274
Ave neighs/atom = 63.637
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37833343085, Press = 0.715495879801662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -3653.6772     -3653.6772     -3724.3048     -3724.3048      273.33601      273.33601      41646.717      41646.717      573.32822      573.32822    
    110000  -3655.378      -3655.378      -3723.8571     -3723.8571      265.02126      265.02126      41970.221      41970.221     -563.0832      -563.0832     
Loop time of 113.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.579 hours/ns, 8.796 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.63     | 112.63     | 112.63     |   0.0 | 99.07
Neigh   | 0.5318     | 0.5318     | 0.5318     |   0.0 |  0.47
Comm    | 0.099932   | 0.099932   | 0.099932   |   0.0 |  0.09
Output  | 0.00022755 | 0.00022755 | 0.00022755 |   0.0 |  0.00
Modify  | 0.36428    | 0.36428    | 0.36428    |   0.0 |  0.32
Other   |            | 0.05936    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126780 ave      126780 max      126780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126780
Ave neighs/atom = 63.39
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.390620154604, Press = 0.574323650655443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -3655.378      -3655.378      -3723.8571     -3723.8571      265.02126      265.02126      41970.221      41970.221     -563.0832      -563.0832     
    111000  -3652.585      -3652.585      -3724.0629     -3724.0629      276.62678      276.62678      41806.767      41806.767      75.139026      75.139026    
Loop time of 113.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.518 hours/ns, 8.813 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.45     | 112.45     | 112.45     |   0.0 | 99.11
Neigh   | 0.4942     | 0.4942     | 0.4942     |   0.0 |  0.44
Comm    | 0.09929    | 0.09929    | 0.09929    |   0.0 |  0.09
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.3602     | 0.3602     | 0.3602     |   0.0 |  0.32
Other   |            | 0.05742    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3848 ave        3848 max        3848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127124 ave      127124 max      127124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127124
Ave neighs/atom = 63.562
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.382966495223, Press = 0.258975458537176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -3652.585      -3652.585      -3724.0629     -3724.0629      276.62678      276.62678      41806.767      41806.767      75.139026      75.139026    
    112000  -3656.7919     -3656.7919     -3726.4687     -3726.4687      269.65632      269.65632      41768.264      41768.264      126.74793      126.74793    
Loop time of 113.027 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.396 hours/ns, 8.847 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112        | 112        | 112        |   0.0 | 99.09
Neigh   | 0.51776    | 0.51776    | 0.51776    |   0.0 |  0.46
Comm    | 0.098648   | 0.098648   | 0.098648   |   0.0 |  0.09
Output  | 0.0001704  | 0.0001704  | 0.0001704  |   0.0 |  0.00
Modify  | 0.35712    | 0.35712    | 0.35712    |   0.0 |  0.32
Other   |            | 0.05657    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3846 ave        3846 max        3846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127174 ave      127174 max      127174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127174
Ave neighs/atom = 63.587
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.370679871442, Press = 0.549390873421909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -3656.7919     -3656.7919     -3726.4687     -3726.4687      269.65632      269.65632      41768.264      41768.264      126.74793      126.74793    
    113000  -3653.3354     -3653.3354     -3724.5307     -3724.5307      275.53345      275.53345      41861.222      41861.222     -205.07359     -205.07359    
Loop time of 126.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.239 hours/ns, 7.883 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.7      | 125.7      | 125.7      |   0.0 | 99.08
Neigh   | 0.53431    | 0.53431    | 0.53431    |   0.0 |  0.42
Comm    | 0.113      | 0.113      | 0.113      |   0.0 |  0.09
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.45002    | 0.45002    | 0.45002    |   0.0 |  0.35
Other   |            | 0.06345    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3775 ave        3775 max        3775 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126900 ave      126900 max      126900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126900
Ave neighs/atom = 63.45
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.372006998553, Press = 0.407145444703348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -3653.3354     -3653.3354     -3724.5307     -3724.5307      275.53345      275.53345      41861.222      41861.222     -205.07359     -205.07359    
    114000  -3656.6856     -3656.6856     -3724.13       -3724.13        261.01677      261.01677      41796.051      41796.051     -81.11019      -81.11019     
Loop time of 120.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.504 hours/ns, 8.291 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.51     | 119.51     | 119.51     |   0.0 | 99.08
Neigh   | 0.52607    | 0.52607    | 0.52607    |   0.0 |  0.44
Comm    | 0.10672    | 0.10672    | 0.10672    |   0.0 |  0.09
Output  | 0.00016875 | 0.00016875 | 0.00016875 |   0.0 |  0.00
Modify  | 0.41372    | 0.41372    | 0.41372    |   0.0 |  0.34
Other   |            | 0.06079    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127008 ave      127008 max      127008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127008
Ave neighs/atom = 63.504
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.350647530539, Press = 0.416940062762876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -3656.6856     -3656.6856     -3724.13       -3724.13        261.01677      261.01677      41796.051      41796.051     -81.11019      -81.11019     
    115000  -3656.305      -3656.305      -3726.7984     -3726.7984      272.8168       272.8168       41693.41       41693.41       321.5491       321.5491     
Loop time of 114.001 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.667 hours/ns, 8.772 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.98     | 112.98     | 112.98     |   0.0 | 99.10
Neigh   | 0.49903    | 0.49903    | 0.49903    |   0.0 |  0.44
Comm    | 0.099402   | 0.099402   | 0.099402   |   0.0 |  0.09
Output  | 0.00017074 | 0.00017074 | 0.00017074 |   0.0 |  0.00
Modify  | 0.3663     | 0.3663     | 0.3663     |   0.0 |  0.32
Other   |            | 0.05763    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3823 ave        3823 max        3823 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127288 ave      127288 max      127288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127288
Ave neighs/atom = 63.644
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.344251807942, Press = 0.41411843412483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -3656.305      -3656.305      -3726.7984     -3726.7984      272.8168       272.8168       41693.41       41693.41       321.5491       321.5491     
    116000  -3649.5021     -3649.5021     -3722.1555     -3722.1555      281.17654      281.17654      41859.837      41859.837     -10.880847     -10.880847    
Loop time of 112.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.309 hours/ns, 8.872 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.71     | 111.71     | 111.71     |   0.0 | 99.11
Neigh   | 0.49322    | 0.49322    | 0.49322    |   0.0 |  0.44
Comm    | 0.098086   | 0.098086   | 0.098086   |   0.0 |  0.09
Output  | 0.00016924 | 0.00016924 | 0.00016924 |   0.0 |  0.00
Modify  | 0.35703    | 0.35703    | 0.35703    |   0.0 |  0.32
Other   |            | 0.05784    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3801 ave        3801 max        3801 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127424 ave      127424 max      127424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127424
Ave neighs/atom = 63.712
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.354444504316, Press = 0.582111406878821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -3649.5021     -3649.5021     -3722.1555     -3722.1555      281.17654      281.17654      41859.837      41859.837     -10.880847     -10.880847    
    117000  -3653.2526     -3653.2526     -3723.2353     -3723.2353      270.84015      270.84015      41997.592      41997.592     -607.66783     -607.66783    
Loop time of 112.639 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.289 hours/ns, 8.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.6      | 111.6      | 111.6      |   0.0 | 99.08
Neigh   | 0.5195     | 0.5195     | 0.5195     |   0.0 |  0.46
Comm    | 0.098917   | 0.098917   | 0.098917   |   0.0 |  0.09
Output  | 0.00016971 | 0.00016971 | 0.00016971 |   0.0 |  0.00
Modify  | 0.35873    | 0.35873    | 0.35873    |   0.0 |  0.32
Other   |            | 0.05825    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3794 ave        3794 max        3794 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126752 ave      126752 max      126752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126752
Ave neighs/atom = 63.376
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.359478198305, Press = 0.00532857843057261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -3653.2526     -3653.2526     -3723.2353     -3723.2353      270.84015      270.84015      41997.592      41997.592     -607.66783     -607.66783    
    118000  -3650.8646     -3650.8646     -3724.2087     -3724.2087      283.84934      283.84934      41648.5        41648.5        644.6599       644.6599     
Loop time of 123.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.276 hours/ns, 8.104 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.26     | 122.26     | 122.26     |   0.0 | 99.08
Neigh   | 0.54103    | 0.54103    | 0.54103    |   0.0 |  0.44
Comm    | 0.10909    | 0.10909    | 0.10909    |   0.0 |  0.09
Output  | 0.00016968 | 0.00016968 | 0.00016968 |   0.0 |  0.00
Modify  | 0.42613    | 0.42613    | 0.42613    |   0.0 |  0.35
Other   |            | 0.06222    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3850 ave        3850 max        3850 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127414 ave      127414 max      127414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127414
Ave neighs/atom = 63.707
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.353964630785, Press = 0.585991375496655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -3650.8646     -3650.8646     -3724.2087     -3724.2087      283.84934      283.84934      41648.5        41648.5        644.6599       644.6599     
    119000  -3655.3107     -3655.3107     -3726.0808     -3726.0808      273.88733      273.88733      41863.88       41863.88      -262.96972     -262.96972    
Loop time of 121.359 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.711 hours/ns, 8.240 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.22     | 120.22     | 120.22     |   0.0 | 99.06
Neigh   | 0.55793    | 0.55793    | 0.55793    |   0.0 |  0.46
Comm    | 0.10792    | 0.10792    | 0.10792    |   0.0 |  0.09
Output  | 0.00017098 | 0.00017098 | 0.00017098 |   0.0 |  0.00
Modify  | 0.41151    | 0.41151    | 0.41151    |   0.0 |  0.34
Other   |            | 0.06159    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126822 ave      126822 max      126822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126822
Ave neighs/atom = 63.411
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.365271330828, Press = 0.556535101482533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -3655.3107     -3655.3107     -3726.0808     -3726.0808      273.88733      273.88733      41863.88       41863.88      -262.96972     -262.96972    
    120000  -3651.8638     -3651.8638     -3723.5356     -3723.5356      277.37728      277.37728      41819.737      41819.737      29.376686      29.376686    
Loop time of 120.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.509 hours/ns, 8.290 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.53     | 119.53     | 119.53     |   0.0 | 99.08
Neigh   | 0.52852    | 0.52852    | 0.52852    |   0.0 |  0.44
Comm    | 0.10552    | 0.10552    | 0.10552    |   0.0 |  0.09
Output  | 0.00020396 | 0.00020396 | 0.00020396 |   0.0 |  0.00
Modify  | 0.40848    | 0.40848    | 0.40848    |   0.0 |  0.34
Other   |            | 0.06153    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3784 ave        3784 max        3784 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127136 ave      127136 max      127136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127136
Ave neighs/atom = 63.568
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.382071342915, Press = 0.4341726451164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -3651.8638     -3651.8638     -3723.5356     -3723.5356      277.37728      277.37728      41819.737      41819.737      29.376686      29.376686    
    121000  -3656.1718     -3656.1718     -3725.7301     -3725.7301      269.19794      269.19794      41817.762      41817.762     -129.85477     -129.85477    
Loop time of 116.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.741 ns/day, 32.409 hours/ns, 8.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.61     | 115.61     | 115.61     |   0.0 | 99.09
Neigh   | 0.50908    | 0.50908    | 0.50908    |   0.0 |  0.44
Comm    | 0.10381    | 0.10381    | 0.10381    |   0.0 |  0.09
Output  | 0.0001677  | 0.0001677  | 0.0001677  |   0.0 |  0.00
Modify  | 0.38933    | 0.38933    | 0.38933    |   0.0 |  0.33
Other   |            | 0.06066    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3810 ave        3810 max        3810 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126910 ave      126910 max      126910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126910
Ave neighs/atom = 63.455
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384418942547, Press = 0.408212464134074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -3656.1718     -3656.1718     -3725.7301     -3725.7301      269.19794      269.19794      41817.762      41817.762     -129.85477     -129.85477    
    122000  -3656.3036     -3656.3036     -3725.1588     -3725.1588      266.47653      266.47653      41605.141      41605.141      623.35769      623.35769    
Loop time of 122.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.038 hours/ns, 8.161 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.4      | 121.4      | 121.4      |   0.0 | 99.07
Neigh   | 0.54288    | 0.54288    | 0.54288    |   0.0 |  0.44
Comm    | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.09
Output  | 0.00016778 | 0.00016778 | 0.00016778 |   0.0 |  0.00
Modify  | 0.42145    | 0.42145    | 0.42145    |   0.0 |  0.34
Other   |            | 0.06198    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3840 ave        3840 max        3840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127308 ave      127308 max      127308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127308
Ave neighs/atom = 63.654
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.362801438014, Press = 0.393837707481514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -3656.3036     -3656.3036     -3725.1588     -3725.1588      266.47653      266.47653      41605.141      41605.141      623.35769      623.35769    
    123000  -3654.5658     -3654.5658     -3724.7037     -3724.7037      271.44103      271.44103      41903.573      41903.573     -318.89749     -318.89749    
Loop time of 114.391 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.775 hours/ns, 8.742 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.34     | 113.34     | 113.34     |   0.0 | 99.08
Neigh   | 0.52395    | 0.52395    | 0.52395    |   0.0 |  0.46
Comm    | 0.10021    | 0.10021    | 0.10021    |   0.0 |  0.09
Output  | 0.00020654 | 0.00020654 | 0.00020654 |   0.0 |  0.00
Modify  | 0.36818    | 0.36818    | 0.36818    |   0.0 |  0.32
Other   |            | 0.05937    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3812 ave        3812 max        3812 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127006 ave      127006 max      127006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127006
Ave neighs/atom = 63.503
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.360140541624, Press = 0.664890165457477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -3654.5658     -3654.5658     -3724.7037     -3724.7037      271.44103      271.44103      41903.573      41903.573     -318.89749     -318.89749    
    124000  -3652.665      -3652.665      -3724.6271     -3724.6271      278.501        278.501        41890.047      41890.047     -303.54628     -303.54628    
Loop time of 124.84 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.678 hours/ns, 8.010 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.7      | 123.7      | 123.7      |   0.0 | 99.08
Neigh   | 0.52896    | 0.52896    | 0.52896    |   0.0 |  0.42
Comm    | 0.11142    | 0.11142    | 0.11142    |   0.0 |  0.09
Output  | 0.00043694 | 0.00043694 | 0.00043694 |   0.0 |  0.00
Modify  | 0.43978    | 0.43978    | 0.43978    |   0.0 |  0.35
Other   |            | 0.06328    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3769 ave        3769 max        3769 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126836 ave      126836 max      126836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126836
Ave neighs/atom = 63.418
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.356028710786, Press = 0.105062846819012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -3652.665      -3652.665      -3724.6271     -3724.6271      278.501        278.501        41890.047      41890.047     -303.54628     -303.54628    
    125000  -3651.9665     -3651.9665     -3725.3874     -3725.3874      284.14683      284.14683      41700.181      41700.181      308.16499      308.16499    
Loop time of 116.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.744 ns/day, 32.263 hours/ns, 8.610 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.11     | 115.11     | 115.11     |   0.0 | 99.11
Neigh   | 0.49912    | 0.49912    | 0.49912    |   0.0 |  0.43
Comm    | 0.1011     | 0.1011     | 0.1011     |   0.0 |  0.09
Output  | 0.00016929 | 0.00016929 | 0.00016929 |   0.0 |  0.00
Modify  | 0.37683    | 0.37683    | 0.37683    |   0.0 |  0.32
Other   |            | 0.06044    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3852 ave        3852 max        3852 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127310 ave      127310 max      127310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127310
Ave neighs/atom = 63.655
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.354328594365, Press = 0.524422474301612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -3651.9665     -3651.9665     -3725.3874     -3725.3874      284.14683      284.14683      41700.181      41700.181      308.16499      308.16499    
    126000  -3655.5112     -3655.5112     -3726.0907     -3726.0907      273.15         273.15         41856.93       41856.93      -140.21481     -140.21481    
Loop time of 120.099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.361 hours/ns, 8.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.01     | 119.01     | 119.01     |   0.0 | 99.10
Neigh   | 0.51949    | 0.51949    | 0.51949    |   0.0 |  0.43
Comm    | 0.10484    | 0.10484    | 0.10484    |   0.0 |  0.09
Output  | 0.00020207 | 0.00020207 | 0.00020207 |   0.0 |  0.00
Modify  | 0.39906    | 0.39906    | 0.39906    |   0.0 |  0.33
Other   |            | 0.0609     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3826 ave        3826 max        3826 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126874 ave      126874 max      126874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126874
Ave neighs/atom = 63.437
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.357843057014, Press = 0.528257867020359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -3655.5112     -3655.5112     -3726.0907     -3726.0907      273.15         273.15         41856.93       41856.93      -140.21481     -140.21481    
    127000  -3653.5232     -3653.5232     -3724.9554     -3724.9554      276.44987      276.44987      41778.9        41778.9        111.86822      111.86822    
Loop time of 112.791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.331 hours/ns, 8.866 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.75     | 111.75     | 111.75     |   0.0 | 99.08
Neigh   | 0.52056    | 0.52056    | 0.52056    |   0.0 |  0.46
Comm    | 0.099939   | 0.099939   | 0.099939   |   0.0 |  0.09
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.35947    | 0.35947    | 0.35947    |   0.0 |  0.32
Other   |            | 0.05932    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3817 ave        3817 max        3817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127324 ave      127324 max      127324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127324
Ave neighs/atom = 63.662
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.379767886932, Press = 0.224125334241259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -3653.5232     -3653.5232     -3724.9554     -3724.9554      276.44987      276.44987      41778.9        41778.9        111.86822      111.86822    
    128000  -3653.111      -3653.111      -3724.7224     -3724.7224      277.14337      277.14337      41842.465      41842.465     -39.464129     -39.464129    
Loop time of 122.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.916 hours/ns, 8.190 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.99     | 120.99     | 120.99     |   0.0 | 99.10
Neigh   | 0.51909    | 0.51909    | 0.51909    |   0.0 |  0.43
Comm    | 0.10678    | 0.10678    | 0.10678    |   0.0 |  0.09
Output  | 0.0001819  | 0.0001819  | 0.0001819  |   0.0 |  0.00
Modify  | 0.41572    | 0.41572    | 0.41572    |   0.0 |  0.34
Other   |            | 0.06205    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3834 ave        3834 max        3834 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127194 ave      127194 max      127194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127194
Ave neighs/atom = 63.597
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.381651019945, Press = 0.685420028341599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -3653.111      -3653.111      -3724.7224     -3724.7224      277.14337      277.14337      41842.465      41842.465     -39.464129     -39.464129    
    129000  -3656.0134     -3656.0134     -3726.0651     -3726.0651      271.10724      271.10724      41963.076      41963.076     -593.86553     -593.86553    
Loop time of 124.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.500 hours/ns, 8.052 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.01     | 123.01     | 123.01     |   0.0 | 99.05
Neigh   | 0.58287    | 0.58287    | 0.58287    |   0.0 |  0.47
Comm    | 0.11011    | 0.11011    | 0.11011    |   0.0 |  0.09
Output  | 0.00016893 | 0.00016893 | 0.00016893 |   0.0 |  0.00
Modify  | 0.42983    | 0.42983    | 0.42983    |   0.0 |  0.35
Other   |            | 0.06265    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3812 ave        3812 max        3812 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126622 ave      126622 max      126622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126622
Ave neighs/atom = 63.311
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377545205453, Press = 0.24000860356439
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -3656.0134     -3656.0134     -3726.0651     -3726.0651      271.10724      271.10724      41963.076      41963.076     -593.86553     -593.86553    
    130000  -3654.5046     -3654.5046     -3724.8704     -3724.8704      272.32285      272.32285      41551.689      41551.689      825.69834      825.69834    
Loop time of 114.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.793 hours/ns, 8.737 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.43     | 113.43     | 113.43     |   0.0 | 99.11
Neigh   | 0.49441    | 0.49441    | 0.49441    |   0.0 |  0.43
Comm    | 0.10125    | 0.10125    | 0.10125    |   0.0 |  0.09
Output  | 0.00020764 | 0.00020764 | 0.00020764 |   0.0 |  0.00
Modify  | 0.36803    | 0.36803    | 0.36803    |   0.0 |  0.32
Other   |            | 0.05925    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3844 ave        3844 max        3844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127410 ave      127410 max      127410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127410
Ave neighs/atom = 63.705
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.39676588828, Press = 0.343902285813053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -3654.5046     -3654.5046     -3724.8704     -3724.8704      272.32285      272.32285      41551.689      41551.689      825.69834      825.69834    
    131000  -3655.6255     -3655.6255     -3726.762      -3726.762       275.30568      275.30568      41876.937      41876.937     -226.04944     -226.04944    
Loop time of 113.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.392 hours/ns, 8.849 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.97     | 111.97     | 111.97     |   0.0 | 99.08
Neigh   | 0.51925    | 0.51925    | 0.51925    |   0.0 |  0.46
Comm    | 0.099869   | 0.099869   | 0.099869   |   0.0 |  0.09
Output  | 0.00016896 | 0.00016896 | 0.00016896 |   0.0 |  0.00
Modify  | 0.36134    | 0.36134    | 0.36134    |   0.0 |  0.32
Other   |            | 0.05847    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3805 ave        3805 max        3805 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126796 ave      126796 max      126796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126796
Ave neighs/atom = 63.398
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396612385882, Press = 0.488111470582657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -3655.6255     -3655.6255     -3726.762      -3726.762       275.30568      275.30568      41876.937      41876.937     -226.04944     -226.04944    
    132000  -3652.5809     -3652.5809     -3724.5039     -3724.5039      278.34963      278.34963      41810.115      41810.115      136.27076      136.27076    
Loop time of 112.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.327 hours/ns, 8.867 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.77     | 111.77     | 111.77     |   0.0 | 99.10
Neigh   | 0.49383    | 0.49383    | 0.49383    |   0.0 |  0.44
Comm    | 0.098752   | 0.098752   | 0.098752   |   0.0 |  0.09
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.35899    | 0.35899    | 0.35899    |   0.0 |  0.32
Other   |            | 0.05796    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3789 ave        3789 max        3789 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126900 ave      126900 max      126900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126900
Ave neighs/atom = 63.45
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404065081337, Press = 0.270136506190277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -3652.5809     -3652.5809     -3724.5039     -3724.5039      278.34963      278.34963      41810.115      41810.115      136.27076      136.27076    
    133000  -3656.4595     -3656.4595     -3725.3758     -3725.3758      266.71322      266.71322      41706.073      41706.073      316.38432      316.38432    
Loop time of 112.86 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.350 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.85     | 111.85     | 111.85     |   0.0 | 99.11
Neigh   | 0.49336    | 0.49336    | 0.49336    |   0.0 |  0.44
Comm    | 0.098991   | 0.098991   | 0.098991   |   0.0 |  0.09
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.35854    | 0.35854    | 0.35854    |   0.0 |  0.32
Other   |            | 0.05804    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3839 ave        3839 max        3839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127380 ave      127380 max      127380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127380
Ave neighs/atom = 63.69
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.400558967988, Press = 0.676186428889004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -3656.4595     -3656.4595     -3725.3758     -3725.3758      266.71322      266.71322      41706.073      41706.073      316.38432      316.38432    
    134000  -3653.5895     -3653.5895     -3725.1583     -3725.1583      276.97834      276.97834      41980.531      41980.531     -552.06284     -552.06284    
Loop time of 112.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.357 hours/ns, 8.858 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.87     | 111.87     | 111.87     |   0.0 | 99.10
Neigh   | 0.49383    | 0.49383    | 0.49383    |   0.0 |  0.44
Comm    | 0.098518   | 0.098518   | 0.098518   |   0.0 |  0.09
Output  | 0.00022071 | 0.00022071 | 0.00022071 |   0.0 |  0.00
Modify  | 0.36029    | 0.36029    | 0.36029    |   0.0 |  0.32
Other   |            | 0.05858    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126668 ave      126668 max      126668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126668
Ave neighs/atom = 63.334
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.407545190859, Press = 0.290302325358428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -3653.5895     -3653.5895     -3725.1583     -3725.1583      276.97834      276.97834      41980.531      41980.531     -552.06284     -552.06284    
    135000  -3654.6502     -3654.6502     -3724.859      -3724.859       271.7153       271.7153       41681.765      41681.765      418.98788      418.98788    
Loop time of 112.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.387 hours/ns, 8.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.98     | 111.98     | 111.98     |   0.0 | 99.11
Neigh   | 0.49393    | 0.49393    | 0.49393    |   0.0 |  0.44
Comm    | 0.098715   | 0.098715   | 0.098715   |   0.0 |  0.09
Output  | 0.00016755 | 0.00016755 | 0.00016755 |   0.0 |  0.00
Modify  | 0.35872    | 0.35872    | 0.35872    |   0.0 |  0.32
Other   |            | 0.05913    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3886 ave        3886 max        3886 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127156 ave      127156 max      127156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127156
Ave neighs/atom = 63.578
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396545003032, Press = 0.270418133784201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -3654.6502     -3654.6502     -3724.859      -3724.859       271.7153       271.7153       41681.765      41681.765      418.98788      418.98788    
    136000  -3653.5818     -3653.5818     -3726.3064     -3726.3064      281.45189      281.45189      41925.913      41925.913     -364.92792     -364.92792    
Loop time of 112.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.363 hours/ns, 8.857 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.87     | 111.87     | 111.87     |   0.0 | 99.08
Neigh   | 0.51765    | 0.51765    | 0.51765    |   0.0 |  0.46
Comm    | 0.099316   | 0.099316   | 0.099316   |   0.0 |  0.09
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.35844    | 0.35844    | 0.35844    |   0.0 |  0.32
Other   |            | 0.05804    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3757 ave        3757 max        3757 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127230 ave      127230 max      127230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127230
Ave neighs/atom = 63.615
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.400660307933, Press = 0.682525158990635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -3653.5818     -3653.5818     -3726.3064     -3726.3064      281.45189      281.45189      41925.913      41925.913     -364.92792     -364.92792    
    137000  -3657.9825     -3657.9825     -3726.412      -3726.412       264.82924      264.82924      41749.736      41749.736      15.998134      15.998134    
Loop time of 112.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.292 hours/ns, 8.877 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.61     | 111.61     | 111.61     |   0.0 | 99.07
Neigh   | 0.52984    | 0.52984    | 0.52984    |   0.0 |  0.47
Comm    | 0.099023   | 0.099023   | 0.099023   |   0.0 |  0.09
Output  | 0.00016853 | 0.00016853 | 0.00016853 |   0.0 |  0.00
Modify  | 0.35643    | 0.35643    | 0.35643    |   0.0 |  0.32
Other   |            | 0.05783    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3821 ave        3821 max        3821 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127068 ave      127068 max      127068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127068
Ave neighs/atom = 63.534
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.388718362957, Press = -0.0222823334768567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -3657.9825     -3657.9825     -3726.412      -3726.412       264.82924      264.82924      41749.736      41749.736      15.998134      15.998134    
    138000  -3652.7784     -3652.7784     -3722.6671     -3722.6671      270.47632      270.47632      41796.046      41796.046      66.088093      66.088093    
Loop time of 112.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.382 hours/ns, 8.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.95     | 111.95     | 111.95     |   0.0 | 99.09
Neigh   | 0.51582    | 0.51582    | 0.51582    |   0.0 |  0.46
Comm    | 0.097463   | 0.097463   | 0.097463   |   0.0 |  0.09
Output  | 0.00020483 | 0.00020483 | 0.00020483 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.32
Other   |            | 0.05811    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3830 ave        3830 max        3830 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127140 ave      127140 max      127140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127140
Ave neighs/atom = 63.57
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.38642568652, Press = 0.593193778672522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -3652.7784     -3652.7784     -3722.6671     -3722.6671      270.47632      270.47632      41796.046      41796.046      66.088093      66.088093    
    139000  -3655.4868     -3655.4868     -3724.4643     -3724.4643      266.94994      266.94994      41832.402      41832.402     -51.494533     -51.494533    
Loop time of 124.836 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.677 hours/ns, 8.011 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.71     | 123.71     | 123.71     |   0.0 | 99.10
Neigh   | 0.52688    | 0.52688    | 0.52688    |   0.0 |  0.42
Comm    | 0.10887    | 0.10887    | 0.10887    |   0.0 |  0.09
Output  | 0.00021395 | 0.00021395 | 0.00021395 |   0.0 |  0.00
Modify  | 0.42513    | 0.42513    | 0.42513    |   0.0 |  0.34
Other   |            | 0.06233    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3824 ave        3824 max        3824 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127030 ave      127030 max      127030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127030
Ave neighs/atom = 63.515
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386780360563, Press = 0.242686343626077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -3655.4868     -3655.4868     -3724.4643     -3724.4643      266.94994      266.94994      41832.402      41832.402     -51.494533     -51.494533    
    140000  -3653.8818     -3653.8818     -3724.6308     -3724.6308      273.80609      273.80609      41750.079      41750.079      147.36169      147.36169    
Loop time of 126.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.257 hours/ns, 7.879 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.74     | 125.74     | 125.74     |   0.0 | 99.07
Neigh   | 0.56308    | 0.56308    | 0.56308    |   0.0 |  0.44
Comm    | 0.11162    | 0.11162    | 0.11162    |   0.0 |  0.09
Output  | 0.00025647 | 0.00025647 | 0.00025647 |   0.0 |  0.00
Modify  | 0.4457     | 0.4457     | 0.4457     |   0.0 |  0.35
Other   |            | 0.06362    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3861 ave        3861 max        3861 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127226 ave      127226 max      127226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127226
Ave neighs/atom = 63.613
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.388936617792, Press = 0.502756316817836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -3653.8818     -3653.8818     -3724.6308     -3724.6308      273.80609      273.80609      41750.079      41750.079      147.36169      147.36169    
    141000  -3653.3834     -3653.3834     -3724.1677     -3724.1677      273.94262      273.94262      41939.224      41939.224     -397.3939      -397.3939     
Loop time of 126.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.225 hours/ns, 7.886 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.63     | 125.63     | 125.63     |   0.0 | 99.07
Neigh   | 0.53746    | 0.53746    | 0.53746    |   0.0 |  0.42
Comm    | 0.11451    | 0.11451    | 0.11451    |   0.0 |  0.09
Output  | 0.00016985 | 0.00016985 | 0.00016985 |   0.0 |  0.00
Modify  | 0.46009    | 0.46009    | 0.46009    |   0.0 |  0.36
Other   |            | 0.06455    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3793 ave        3793 max        3793 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126932 ave      126932 max      126932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126932
Ave neighs/atom = 63.466
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384801818246, Press = 0.24348206991123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -3653.3834     -3653.3834     -3724.1677     -3724.1677      273.94262      273.94262      41939.224      41939.224     -397.3939      -397.3939     
    142000  -3656.2376     -3656.2376     -3726.1551     -3726.1551      270.58795      270.58795      41558.345      41558.345      822.4436       822.4436     
Loop time of 113.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.628 hours/ns, 8.783 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.84     | 112.84     | 112.84     |   0.0 | 99.10
Neigh   | 0.49734    | 0.49734    | 0.49734    |   0.0 |  0.44
Comm    | 0.10017    | 0.10017    | 0.10017    |   0.0 |  0.09
Output  | 0.00017064 | 0.00017064 | 0.00017064 |   0.0 |  0.00
Modify  | 0.36624    | 0.36624    | 0.36624    |   0.0 |  0.32
Other   |            | 0.05845    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3894 ave        3894 max        3894 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127262 ave      127262 max      127262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127262
Ave neighs/atom = 63.631
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.360212130627, Press = 0.361222388516065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -3656.2376     -3656.2376     -3726.1551     -3726.1551      270.58795      270.58795      41558.345      41558.345      822.4436       822.4436     
    143000  -3654.1385     -3654.1385     -3725.0115     -3725.0115      274.28563      274.28563      41895.75       41895.75      -346.31739     -346.31739    
Loop time of 112.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.375 hours/ns, 8.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.92     | 111.92     | 111.92     |   0.0 | 99.09
Neigh   | 0.51696    | 0.51696    | 0.51696    |   0.0 |  0.46
Comm    | 0.098024   | 0.098024   | 0.098024   |   0.0 |  0.09
Output  | 0.00021779 | 0.00021779 | 0.00021779 |   0.0 |  0.00
Modify  | 0.35693    | 0.35693    | 0.35693    |   0.0 |  0.32
Other   |            | 0.05858    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3786 ave        3786 max        3786 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127048 ave      127048 max      127048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127048
Ave neighs/atom = 63.524
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.354101167338, Press = 0.579820751743153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -3654.1385     -3654.1385     -3725.0115     -3725.0115      274.28563      274.28563      41895.75       41895.75      -346.31739     -346.31739    
    144000  -3658.5818     -3658.5818     -3724.7584     -3724.7584      256.11032      256.11032      41719.331      41719.331      90.031267      90.031267    
Loop time of 114.175 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.757 ns/day, 31.715 hours/ns, 8.758 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.16     | 113.16     | 113.16     |   0.0 | 99.11
Neigh   | 0.49632    | 0.49632    | 0.49632    |   0.0 |  0.43
Comm    | 0.099232   | 0.099232   | 0.099232   |   0.0 |  0.09
Output  | 0.00017029 | 0.00017029 | 0.00017029 |   0.0 |  0.00
Modify  | 0.36358    | 0.36358    | 0.36358    |   0.0 |  0.32
Other   |            | 0.05941    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3840 ave        3840 max        3840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126904 ave      126904 max      126904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126904
Ave neighs/atom = 63.452
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.354095793656, Press = 0.26214068150602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -3658.5818     -3658.5818     -3724.7584     -3724.7584      256.11032      256.11032      41719.331      41719.331      90.031267      90.031267    
    145000  -3654.4717     -3654.4717     -3723.0741     -3723.0741      265.49869      265.49869      41815.048      41815.048     -17.247604     -17.247604    
Loop time of 113.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.464 hours/ns, 8.828 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.10
Neigh   | 0.4961     | 0.4961     | 0.4961     |   0.0 |  0.44
Comm    | 0.099094   | 0.099094   | 0.099094   |   0.0 |  0.09
Output  | 0.00017006 | 0.00017006 | 0.00017006 |   0.0 |  0.00
Modify  | 0.35972    | 0.35972    | 0.35972    |   0.0 |  0.32
Other   |            | 0.05911    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3824 ave        3824 max        3824 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127358 ave      127358 max      127358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127358
Ave neighs/atom = 63.679
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.343999998514, Press = 0.425259685969535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -3654.4717     -3654.4717     -3723.0741     -3723.0741      265.49869      265.49869      41815.048      41815.048     -17.247604     -17.247604    
    146000  -3660.3675     -3660.3675     -3727.6815     -3727.6815      260.51217      260.51217      41868.893      41868.893     -401.05572     -401.05572    
Loop time of 113.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.463 hours/ns, 8.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.08
Neigh   | 0.52081    | 0.52081    | 0.52081    |   0.0 |  0.46
Comm    | 0.098717   | 0.098717   | 0.098717   |   0.0 |  0.09
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.35792    | 0.35792    | 0.35792    |   0.0 |  0.32
Other   |            | 0.05913    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3826 ave        3826 max        3826 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126834 ave      126834 max      126834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126834
Ave neighs/atom = 63.417
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.331598237443, Press = 0.326429349353521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -3660.3675     -3660.3675     -3727.6815     -3727.6815      260.51217      260.51217      41868.893      41868.893     -401.05572     -401.05572    
    147000  -3654.2105     -3654.2105     -3725.9946     -3725.9946      277.81182      277.81182      41677.808      41677.808      374.21901      374.21901    
Loop time of 113.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.531 hours/ns, 8.810 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.47     | 112.47     | 112.47     |   0.0 | 99.09
Neigh   | 0.51989    | 0.51989    | 0.51989    |   0.0 |  0.46
Comm    | 0.099444   | 0.099444   | 0.099444   |   0.0 |  0.09
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.35966    | 0.35966    | 0.35966    |   0.0 |  0.32
Other   |            | 0.05937    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3843 ave        3843 max        3843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127360 ave      127360 max      127360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127360
Ave neighs/atom = 63.68
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.309024046653, Press = 0.324550459915716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -3654.2105     -3654.2105     -3725.9946     -3725.9946      277.81182      277.81182      41677.808      41677.808      374.21901      374.21901    
    148000  -3655.881      -3655.881      -3724.8805     -3724.8805      267.03513      267.03513      42060.387      42060.387     -836.82819     -836.82819    
Loop time of 117.396 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.610 hours/ns, 8.518 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.29     | 116.29     | 116.29     |   0.0 | 99.05
Neigh   | 0.56191    | 0.56191    | 0.56191    |   0.0 |  0.48
Comm    | 0.10408    | 0.10408    | 0.10408    |   0.0 |  0.09
Output  | 0.00024832 | 0.00024832 | 0.00024832 |   0.0 |  0.00
Modify  | 0.38267    | 0.38267    | 0.38267    |   0.0 |  0.33
Other   |            | 0.06062    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3839 ave        3839 max        3839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126684 ave      126684 max      126684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126684
Ave neighs/atom = 63.342
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.312151188952, Press = 0.608952976537993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -3655.881      -3655.881      -3724.8805     -3724.8805      267.03513      267.03513      42060.387      42060.387     -836.82819     -836.82819    
    149000  -3653.3817     -3653.3817     -3723.7923     -3723.7923      272.49622      272.49622      41794.181      41794.181      129.18237      129.18237    
Loop time of 127.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.338 hours/ns, 7.861 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.03     | 126.03     | 126.03     |   0.0 | 99.07
Neigh   | 0.56123    | 0.56123    | 0.56123    |   0.0 |  0.44
Comm    | 0.11227    | 0.11227    | 0.11227    |   0.0 |  0.09
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.44574    | 0.44574    | 0.44574    |   0.0 |  0.35
Other   |            | 0.0638     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3782 ave        3782 max        3782 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127064 ave      127064 max      127064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127064
Ave neighs/atom = 63.532
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
41803.7932720694

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0