# 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.4522534608840942*${_u_distance}
variable latticeconst_converted equal 3.4522534608840942*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.45225346088409
Lattice spacing in x,y,z = 3.4522535 3.4522535 3.4522535
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (34.522535 34.522535 34.522535)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (34.522535 34.522535 34.522535)
  create_atoms CPU = 0.003 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_CuiGaoCui_2012_LiSi__MO_557492625287_001
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 41144.1430241516    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 41144.1430241516/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 41144.1430241516/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 41144.1430241516/(1*1*${_u_distance})
variable      V0_metal equal 41144.1430241516/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 41144.1430241516*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 41144.1430241516 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_557492625287_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -3224.0166   -3224.0166   -3294.5961   -3294.5961       273.15       273.15    41144.143    41144.143    1832.2746    1832.2746 
    1000   -3152.5889   -3152.5889   -3221.9841   -3221.9841    268.56659    268.56659    42786.829    42786.829   -225.27819   -225.27819 
Loop time of 136.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.633 ns/day, 37.905 hours/ns, 7.328 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.48     | 135.48     | 135.48     |   0.0 | 99.28
Neigh   | 0.44357    | 0.44357    | 0.44357    |   0.0 |  0.33
Comm    | 0.093516   | 0.093516   | 0.093516   |   0.0 |  0.07
Output  | 0.00026421 | 0.00026421 | 0.00026421 |   0.0 |  0.00
Modify  | 0.38813    | 0.38813    | 0.38813    |   0.0 |  0.28
Other   |            | 0.05799    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3140.00 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119126.0 ave      119126 max      119126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119126
Ave neighs/atom = 59.563000
Neighbor list builds = 19
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -3152.5889   -3152.5889   -3221.9841   -3221.9841    268.56659    268.56659    42786.829    42786.829   -225.27819   -225.27819 
    2000   -3154.6156   -3154.6156    -3225.319    -3225.319    273.62913    273.62913    42728.302    42728.302   -172.15408   -172.15408 
Loop time of 138.729 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.536 hours/ns, 7.208 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    | 137.7      | 137.7      | 137.7      |   0.0 | 99.26
Neigh   | 0.48386    | 0.48386    | 0.48386    |   0.0 |  0.35
Comm    | 0.094913   | 0.094913   | 0.094913   |   0.0 |  0.07
Output  | 0.00022244 | 0.00022244 | 0.00022244 |   0.0 |  0.00
Modify  | 0.38895    | 0.38895    | 0.38895    |   0.0 |  0.28
Other   |            | 0.05873    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3150.00 ave        3150 max        3150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119098.0 ave      119098 max      119098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119098
Ave neighs/atom = 59.549000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -3154.6156   -3154.6156    -3225.319    -3225.319    273.62913    273.62913    42728.302    42728.302   -172.15408   -172.15408 
    3000    -3152.108    -3152.108   -3223.5486   -3223.5486    276.48253    276.48253    42622.429    42622.429    237.18234    237.18234 
Loop time of 123.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.291 hours/ns, 8.101 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.5      | 122.5      | 122.5      |   0.0 | 99.23
Neigh   | 0.4727     | 0.4727     | 0.4727     |   0.0 |  0.38
Comm    | 0.087618   | 0.087618   | 0.087618   |   0.0 |  0.07
Output  | 0.00018885 | 0.00018885 | 0.00018885 |   0.0 |  0.00
Modify  | 0.33313    | 0.33313    | 0.33313    |   0.0 |  0.27
Other   |            | 0.05423    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3150.00 ave        3150 max        3150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119160.0 ave      119160 max      119160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119160
Ave neighs/atom = 59.580000
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -3152.108    -3152.108   -3223.5486   -3223.5486    276.48253    276.48253    42622.429    42622.429    237.18234    237.18234 
    4000   -3153.2408   -3153.2408   -3224.9196   -3224.9196     277.4046     277.4046    42735.998    42735.998   -81.721403   -81.721403 
Loop time of 123.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.302 hours/ns, 8.098 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.54     | 122.54     | 122.54     |   0.0 | 99.23
Neigh   | 0.47268    | 0.47268    | 0.47268    |   0.0 |  0.38
Comm    | 0.086696   | 0.086696   | 0.086696   |   0.0 |  0.07
Output  | 0.00018996 | 0.00018996 | 0.00018996 |   0.0 |  0.00
Modify  | 0.33293    | 0.33293    | 0.33293    |   0.0 |  0.27
Other   |            | 0.05411    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3142.00 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119100.0 ave      119100 max      119100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119100
Ave neighs/atom = 59.550000
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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -3153.2408   -3153.2408   -3224.9196   -3224.9196     277.4046     277.4046    42735.998    42735.998   -81.721403   -81.721403 
    5000   -3153.4433   -3153.4433   -3224.4032   -3224.4032    274.62205    274.62205    42832.743    42832.743   -460.35986   -460.35986 
Loop time of 123.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.432 hours/ns, 8.067 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        | 123        | 123        |   0.0 | 99.23
Neigh   | 0.475      | 0.475      | 0.475      |   0.0 |  0.38
Comm    | 0.087962   | 0.087962   | 0.087962   |   0.0 |  0.07
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.3364     | 0.3364     | 0.3364     |   0.0 |  0.27
Other   |            | 0.05387    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3112.00 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119016.0 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508000
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 = 274.236609709462, Press = -437.144216823777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -3153.4433   -3153.4433   -3224.4032   -3224.4032    274.62205    274.62205    42832.743    42832.743   -460.35986   -460.35986 
    6000   -3150.8757   -3150.8757   -3221.8261   -3221.8261    274.58554    274.58554    42746.338    42746.338   -80.732448   -80.732448 
Loop time of 124.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.547 hours/ns, 8.041 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.4      | 123.4      | 123.4      |   0.0 | 99.22
Neigh   | 0.47632    | 0.47632    | 0.47632    |   0.0 |  0.38
Comm    | 0.08841    | 0.08841    | 0.08841    |   0.0 |  0.07
Output  | 0.00018836 | 0.00018836 | 0.00018836 |   0.0 |  0.00
Modify  | 0.35206    | 0.35206    | 0.35206    |   0.0 |  0.28
Other   |            | 0.05383    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3100.00 ave        3100 max        3100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119124.0 ave      119124 max      119124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119124
Ave neighs/atom = 59.562000
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.689052083132, Press = -49.655401066224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -3150.8757   -3150.8757   -3221.8261   -3221.8261    274.58554    274.58554    42746.338    42746.338   -80.732448   -80.732448 
    7000   -3154.1976   -3154.1976   -3225.0907   -3225.0907    274.36353    274.36353    42570.853    42570.853    231.69771    231.69771 
Loop time of 124.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.542 hours/ns, 8.042 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.38     | 123.38     | 123.38     |   0.0 | 99.22
Neigh   | 0.47778    | 0.47778    | 0.47778    |   0.0 |  0.38
Comm    | 0.088716   | 0.088716   | 0.088716   |   0.0 |  0.07
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.35298    | 0.35298    | 0.35298    |   0.0 |  0.28
Other   |            | 0.05321    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3151.00 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119092.0 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546000
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.46982530818, Press = -6.32879828659526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -3154.1976   -3154.1976   -3225.0907   -3225.0907    274.36353    274.36353    42570.853    42570.853    231.69771    231.69771 
    8000   -3152.6678   -3152.6678   -3222.4818   -3222.4818     270.1871     270.1871    42801.946    42801.946    -259.2914    -259.2914 
Loop time of 124.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.604 hours/ns, 8.027 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.61     | 123.61     | 123.61     |   0.0 | 99.22
Neigh   | 0.47636    | 0.47636    | 0.47636    |   0.0 |  0.38
Comm    | 0.088444   | 0.088444   | 0.088444   |   0.0 |  0.07
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.35168    | 0.35168    | 0.35168    |   0.0 |  0.28
Other   |            | 0.05333    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3167.00 ave        3167 max        3167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119002.0 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501000
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 = 272.510442221336, Press = -1.01335742933929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -3152.6678   -3152.6678   -3222.4818   -3222.4818     270.1871     270.1871    42801.946    42801.946    -259.2914    -259.2914 
    9000   -3153.0286   -3153.0286   -3222.8822   -3222.8822    270.34081    270.34081    42831.321    42831.321   -291.89043   -291.89043 
Loop time of 124.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.453 hours/ns, 8.062 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.06     | 123.06     | 123.06     |   0.0 | 99.22
Neigh   | 0.47746    | 0.47746    | 0.47746    |   0.0 |  0.38
Comm    | 0.087939   | 0.087939   | 0.087939   |   0.0 |  0.07
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.35289    | 0.35289    | 0.35289    |   0.0 |  0.28
Other   |            | 0.05442    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3125.00 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119072.0 ave      119072 max      119072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119072
Ave neighs/atom = 59.536000
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 = 272.541540020144, Press = -11.3035963735238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -3153.0286   -3153.0286   -3222.8822   -3222.8822    270.34081    270.34081    42831.321    42831.321   -291.89043   -291.89043 
   10000   -3151.0587   -3151.0587   -3222.2636   -3222.2636    275.57034    275.57034    42459.488    42459.488    794.50341    794.50341 
Loop time of 123.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.279 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.44     | 122.44     | 122.44     |   0.0 | 99.22
Neigh   | 0.47242    | 0.47242    | 0.47242    |   0.0 |  0.38
Comm    | 0.087187   | 0.087187   | 0.087187   |   0.0 |  0.07
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.35129    | 0.35129    | 0.35129    |   0.0 |  0.28
Other   |            | 0.05521    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3163.00 ave        3163 max        3163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119326.0 ave      119326 max      119326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119326
Ave neighs/atom = 59.663000
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 = 272.485868067925, Press = -8.42295279476008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -3151.0587   -3151.0587   -3222.2636   -3222.2636    275.57034    275.57034    42459.488    42459.488    794.50341    794.50341 
   11000   -3151.1979   -3151.1979   -3222.3761   -3222.3761     275.4669     275.4669    42776.929    42776.929   -167.94108   -167.94108 
Loop time of 124.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.624 hours/ns, 8.023 timesteps/s
99.8% 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.67     | 123.67     | 123.67     |   0.0 | 99.22
Neigh   | 0.4762     | 0.4762     | 0.4762     |   0.0 |  0.38
Comm    | 0.087489   | 0.087489   | 0.087489   |   0.0 |  0.07
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.35431    | 0.35431    | 0.35431    |   0.0 |  0.28
Other   |            | 0.05549    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3143.00 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119074.0 ave      119074 max      119074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119074
Ave neighs/atom = 59.537000
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 = 272.730299729548, Press = 3.4921449539351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -3151.1979   -3151.1979   -3222.3761   -3222.3761     275.4669     275.4669    42776.929    42776.929   -167.94108   -167.94108 
   12000   -3154.5635   -3154.5635   -3225.4611   -3225.4611    274.38095    274.38095    42771.448    42771.448   -268.53113   -268.53113 
Loop time of 124.271 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.520 hours/ns, 8.047 timesteps/s
99.8% 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.3      | 123.3      | 123.3      |   0.0 | 99.22
Neigh   | 0.47704    | 0.47704    | 0.47704    |   0.0 |  0.38
Comm    | 0.087321   | 0.087321   | 0.087321   |   0.0 |  0.07
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.35502    | 0.35502    | 0.35502    |   0.0 |  0.29
Other   |            | 0.05466    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3156.00 ave        3156 max        3156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119144.0 ave      119144 max      119144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119144
Ave neighs/atom = 59.572000
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.098112701894, Press = -3.91373758090389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -3154.5635   -3154.5635   -3225.4611   -3225.4611    274.38095    274.38095    42771.448    42771.448   -268.53113   -268.53113 
   13000   -3153.3697   -3153.3697   -3222.8045   -3222.8045    268.71995    268.71995    42638.686    42638.686    163.59536    163.59536 
Loop time of 124.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.524 hours/ns, 8.046 timesteps/s
99.8% 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.31     | 123.31     | 123.31     |   0.0 | 99.22
Neigh   | 0.47709    | 0.47709    | 0.47709    |   0.0 |  0.38
Comm    | 0.088123   | 0.088123   | 0.088123   |   0.0 |  0.07
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.35433    | 0.35433    | 0.35433    |   0.0 |  0.29
Other   |            | 0.05515    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3181.00 ave        3181 max        3181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119158.0 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579000
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.308404141565, Press = -7.1206792434056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -3153.3697   -3153.3697   -3222.8045   -3222.8045    268.71995    268.71995    42638.686    42638.686    163.59536    163.59536 
   14000   -3152.3443   -3152.3443   -3221.9376   -3221.9376    269.33308    269.33308    42635.493    42635.493    257.57315    257.57315 
Loop time of 123.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.376 hours/ns, 8.081 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.79     | 122.79     | 122.79     |   0.0 | 99.22
Neigh   | 0.4736     | 0.4736     | 0.4736     |   0.0 |  0.38
Comm    | 0.087179   | 0.087179   | 0.087179   |   0.0 |  0.07
Output  | 0.00015255 | 0.00015255 | 0.00015255 |   0.0 |  0.00
Modify  | 0.35204    | 0.35204    | 0.35204    |   0.0 |  0.28
Other   |            | 0.05484    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3159.00 ave        3159 max        3159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119186.0 ave      119186 max      119186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119186
Ave neighs/atom = 59.593000
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.284152390468, Press = -2.25493062563716
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -3152.3443   -3152.3443   -3221.9376   -3221.9376    269.33308    269.33308    42635.493    42635.493    257.57315    257.57315 
   15000   -3151.7392   -3151.7392   -3221.9888   -3221.9888    271.87328    271.87328     42733.33     42733.33   -18.627077   -18.627077 
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.43     | 122.43     | 122.43     |   0.0 | 99.22
Neigh   | 0.47233    | 0.47233    | 0.47233    |   0.0 |  0.38
Comm    | 0.086787   | 0.086787   | 0.086787   |   0.0 |  0.07
Output  | 0.00041828 | 0.00041828 | 0.00041828 |   0.0 |  0.00
Modify  | 0.35127    | 0.35127    | 0.35127    |   0.0 |  0.28
Other   |            | 0.05464    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3180.00 ave        3180 max        3180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119118.0 ave      119118 max      119118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119118
Ave neighs/atom = 59.559000
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.307191591586, Press = 1.34730008703729
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -3151.7392   -3151.7392   -3221.9888   -3221.9888    271.87328    271.87328     42733.33     42733.33   -18.627077   -18.627077 
   16000   -3154.6982   -3154.6982   -3221.8494   -3221.8494    259.88208    259.88208    42917.138    42917.138   -600.02156   -600.02156 
Loop time of 133.723 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.145 hours/ns, 7.478 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    | 132.67     | 132.67     | 132.67     |   0.0 | 99.21
Neigh   | 0.51627    | 0.51627    | 0.51627    |   0.0 |  0.39
Comm    | 0.093027   | 0.093027   | 0.093027   |   0.0 |  0.07
Output  | 0.00019083 | 0.00019083 | 0.00019083 |   0.0 |  0.00
Modify  | 0.38934    | 0.38934    | 0.38934    |   0.0 |  0.29
Other   |            | 0.05651    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3109.00 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118976.0 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488000
Neighbor list builds = 23
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.387545811141, Press = -1.87012010179502
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -3154.6982   -3154.6982   -3221.8494   -3221.8494    259.88208    259.88208    42917.138    42917.138   -600.02156   -600.02156 
   17000   -3148.7732   -3148.7732   -3218.7975   -3218.7975    271.00121    271.00121    42722.521    42722.521    162.13573    162.13573 
Loop time of 141.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.307 hours/ns, 7.067 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    | 140.42     | 140.42     | 140.42     |   0.0 | 99.23
Neigh   | 0.50989    | 0.50989    | 0.50989    |   0.0 |  0.36
Comm    | 0.096399   | 0.096399   | 0.096399   |   0.0 |  0.07
Output  | 0.00015374 | 0.00015374 | 0.00015374 |   0.0 |  0.00
Modify  | 0.42079    | 0.42079    | 0.42079    |   0.0 |  0.30
Other   |            | 0.0578     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3131.00 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118988.0 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494000
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.486235791521, Press = -5.74490668314715
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -3148.7732   -3148.7732   -3218.7975   -3218.7975    271.00121    271.00121    42722.521    42722.521    162.13573    162.13573 
   18000   -3152.0429   -3152.0429    -3223.223    -3223.223    275.47443    275.47443    42606.288    42606.288    318.77513    318.77513 
Loop time of 123.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.412 hours/ns, 8.072 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.94     | 122.94     | 122.94     |   0.0 | 99.23
Neigh   | 0.45186    | 0.45186    | 0.45186    |   0.0 |  0.36
Comm    | 0.088014   | 0.088014   | 0.088014   |   0.0 |  0.07
Output  | 0.00015273 | 0.00015273 | 0.00015273 |   0.0 |  0.00
Modify  | 0.35327    | 0.35327    | 0.35327    |   0.0 |  0.29
Other   |            | 0.05456    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3170.00 ave        3170 max        3170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119266.0 ave      119266 max      119266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119266
Ave neighs/atom = 59.633000
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.491934992013, Press = -0.237401546326298
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -3152.0429   -3152.0429    -3223.223    -3223.223    275.47443    275.47443    42606.288    42606.288    318.77513    318.77513 
   19000   -3153.0239   -3153.0239   -3223.7284   -3223.7284    273.63384    273.63384    42813.169    42813.169   -370.18917   -370.18917 
Loop time of 123.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.310 hours/ns, 8.096 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.55     | 122.55     | 122.55     |   0.0 | 99.22
Neigh   | 0.47345    | 0.47345    | 0.47345    |   0.0 |  0.38
Comm    | 0.087508   | 0.087508   | 0.087508   |   0.0 |  0.07
Output  | 0.00019111 | 0.00019111 | 0.00019111 |   0.0 |  0.00
Modify  | 0.35325    | 0.35325    | 0.35325    |   0.0 |  0.29
Other   |            | 0.05476    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3159.00 ave        3159 max        3159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119062.0 ave      119062 max      119062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119062
Ave neighs/atom = 59.531000
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.490865356826, Press = -2.01319492432613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -3153.0239   -3153.0239   -3223.7284   -3223.7284    273.63384    273.63384    42813.169    42813.169   -370.18917   -370.18917 
   20000   -3152.7708   -3152.7708   -3223.8753   -3223.8753    275.18147    275.18147     42720.71     42720.71    -100.0602    -100.0602 
Loop time of 123.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.343 hours/ns, 8.088 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.67     | 122.67     | 122.67     |   0.0 | 99.22
Neigh   | 0.47348    | 0.47348    | 0.47348    |   0.0 |  0.38
Comm    | 0.087419   | 0.087419   | 0.087419   |   0.0 |  0.07
Output  | 0.00018818 | 0.00018818 | 0.00018818 |   0.0 |  0.00
Modify  | 0.35274    | 0.35274    | 0.35274    |   0.0 |  0.29
Other   |            | 0.05446    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3160.00 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119076.0 ave      119076 max      119076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119076
Ave neighs/atom = 59.538000
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.398750984281, Press = -2.37496955406358
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -3152.7708   -3152.7708   -3223.8753   -3223.8753    275.18147    275.18147     42720.71     42720.71    -100.0602    -100.0602 
   21000   -3151.8528   -3151.8528   -3223.2073   -3223.2073     276.1494     276.1494    42689.784    42689.784    35.800538    35.800538 
Loop time of 123.61 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.699 ns/day, 34.336 hours/ns, 8.090 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.66     | 122.66     | 122.66     |   0.0 | 99.23
Neigh   | 0.45181    | 0.45181    | 0.45181    |   0.0 |  0.37
Comm    | 0.086754   | 0.086754   | 0.086754   |   0.0 |  0.07
Output  | 0.00015298 | 0.00015298 | 0.00015298 |   0.0 |  0.00
Modify  | 0.35344    | 0.35344    | 0.35344    |   0.0 |  0.29
Other   |            | 0.05437    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3114.00 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119158.0 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579000
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.507036923722, Press = -2.02723221347087
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -3151.8528   -3151.8528   -3223.2073   -3223.2073     276.1494     276.1494    42689.784    42689.784    35.800538    35.800538 
   22000   -3152.1415   -3152.1415   -3222.6281   -3222.6281    272.79036    272.79036    42734.525    42734.525     -38.3618     -38.3618 
Loop time of 125.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.819 hours/ns, 7.978 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    | 124.37     | 124.37     | 124.37     |   0.0 | 99.22
Neigh   | 0.48171    | 0.48171    | 0.48171    |   0.0 |  0.38
Comm    | 0.089622   | 0.089622   | 0.089622   |   0.0 |  0.07
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.35706    | 0.35706    | 0.35706    |   0.0 |  0.28
Other   |            | 0.05386    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3153.00 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119076.0 ave      119076 max      119076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119076
Ave neighs/atom = 59.538000
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.539764698078, Press = -0.395110658072836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -3152.1415   -3152.1415   -3222.6281   -3222.6281    272.79036    272.79036    42734.525    42734.525     -38.3618     -38.3618 
   23000   -3154.5265   -3154.5265    -3223.804    -3223.804    268.11084    268.11084    42724.632    42724.632   -81.447863   -81.447863 
Loop time of 125.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.819 hours/ns, 7.978 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    | 124.37     | 124.37     | 124.37     |   0.0 | 99.22
Neigh   | 0.48009    | 0.48009    | 0.48009    |   0.0 |  0.38
Comm    | 0.089298   | 0.089298   | 0.089298   |   0.0 |  0.07
Output  | 0.00014651 | 0.00014651 | 0.00014651 |   0.0 |  0.00
Modify  | 0.35776    | 0.35776    | 0.35776    |   0.0 |  0.29
Other   |            | 0.05409    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3120.00 ave        3120 max        3120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119148.0 ave      119148 max      119148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119148
Ave neighs/atom = 59.574000
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.614767290387, Press = -0.83965157974012
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -3154.5265   -3154.5265    -3223.804    -3223.804    268.11084    268.11084    42724.632    42724.632   -81.447863   -81.447863 
   24000   -3151.1755   -3151.1755   -3223.1855   -3223.1855    278.68614    278.68614    42888.379    42888.379   -497.38782   -497.38782 
Loop time of 121.738 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.816 hours/ns, 8.214 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.78     | 120.78     | 120.78     |   0.0 | 99.21
Neigh   | 0.46697    | 0.46697    | 0.46697    |   0.0 |  0.38
Comm    | 0.086303   | 0.086303   | 0.086303   |   0.0 |  0.07
Output  | 0.00014698 | 0.00014698 | 0.00014698 |   0.0 |  0.00
Modify  | 0.35066    | 0.35066    | 0.35066    |   0.0 |  0.29
Other   |            | 0.0541     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3137.00 ave        3137 max        3137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118940.0 ave      118940 max      118940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118940
Ave neighs/atom = 59.470000
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.591123816937, Press = -3.60692295763766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -3151.1755   -3151.1755   -3223.1855   -3223.1855    278.68614    278.68614    42888.379    42888.379   -497.38782   -497.38782 
   25000   -3149.4716   -3149.4716   -3222.9189   -3222.9189    284.24873    284.24873    42572.856    42572.856    451.94096    451.94096 
Loop time of 121.192 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.664 hours/ns, 8.251 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.24     | 120.24     | 120.24     |   0.0 | 99.22
Neigh   | 0.46257    | 0.46257    | 0.46257    |   0.0 |  0.38
Comm    | 0.086779   | 0.086779   | 0.086779   |   0.0 |  0.07
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.34664    | 0.34664    | 0.34664    |   0.0 |  0.29
Other   |            | 0.05367    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3151.00 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119276.0 ave      119276 max      119276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119276
Ave neighs/atom = 59.638000
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.570907592644, Press = -1.43007556078515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -3149.4716   -3149.4716   -3222.9189   -3222.9189    284.24873    284.24873    42572.856    42572.856    451.94096    451.94096 
   26000   -3154.3028   -3154.3028   -3223.0208   -3223.0208    265.94562    265.94562    42752.152    42752.152   -114.98004   -114.98004 
Loop time of 121.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.631 hours/ns, 8.260 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.1      | 120.1      | 120.1      |   0.0 | 99.20
Neigh   | 0.48517    | 0.48517    | 0.48517    |   0.0 |  0.40
Comm    | 0.085373   | 0.085373   | 0.085373   |   0.0 |  0.07
Output  | 0.00014412 | 0.00014412 | 0.00014412 |   0.0 |  0.00
Modify  | 0.34615    | 0.34615    | 0.34615    |   0.0 |  0.29
Other   |            | 0.0533     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3157.00 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119058.0 ave      119058 max      119058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119058
Ave neighs/atom = 59.529000
Neighbor list builds = 23
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.589282365782, Press = -0.587685251196414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -3154.3028   -3154.3028   -3223.0208   -3223.0208    265.94562    265.94562    42752.152    42752.152   -114.98004   -114.98004 
   27000   -3155.1639   -3155.1639    -3224.916    -3224.916    269.94771    269.94771    42674.974    42674.974    17.755086    17.755086 
Loop time of 120.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.595 hours/ns, 8.268 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.02     | 120.02     | 120.02     |   0.0 | 99.23
Neigh   | 0.4422     | 0.4422     | 0.4422     |   0.0 |  0.37
Comm    | 0.08483    | 0.08483    | 0.08483    |   0.0 |  0.07
Output  | 0.00014386 | 0.00014386 | 0.00014386 |   0.0 |  0.00
Modify  | 0.34696    | 0.34696    | 0.34696    |   0.0 |  0.29
Other   |            | 0.05413    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3104.00 ave        3104 max        3104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119036.0 ave      119036 max      119036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119036
Ave neighs/atom = 59.518000
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.558592798767, Press = -1.86143159211014
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -3155.1639   -3155.1639    -3224.916    -3224.916    269.94771    269.94771    42674.974    42674.974    17.755086    17.755086 
   28000   -3151.7718   -3151.7718   -3220.7706   -3220.7706    267.03245    267.03245    42590.641    42590.641    449.83084    449.83084 
Loop time of 121.175 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.660 hours/ns, 8.253 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.23     | 120.23     | 120.23     |   0.0 | 99.22
Neigh   | 0.46401    | 0.46401    | 0.46401    |   0.0 |  0.38
Comm    | 0.085294   | 0.085294   | 0.085294   |   0.0 |  0.07
Output  | 0.00019091 | 0.00019091 | 0.00019091 |   0.0 |  0.00
Modify  | 0.34578    | 0.34578    | 0.34578    |   0.0 |  0.29
Other   |            | 0.05392    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3138.00 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119170.0 ave      119170 max      119170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119170
Ave neighs/atom = 59.585000
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.54726093114, Press = -1.36483973879453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -3151.7718   -3151.7718   -3220.7706   -3220.7706    267.03245    267.03245    42590.641    42590.641    449.83084    449.83084 
   29000    -3153.141    -3153.141   -3223.2674   -3223.2674     271.3967     271.3967    42667.473    42667.473    72.637721    72.637721 
Loop time of 121.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.737 hours/ns, 8.234 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.5      | 120.5      | 120.5      |   0.0 | 99.22
Neigh   | 0.4639     | 0.4639     | 0.4639     |   0.0 |  0.38
Comm    | 0.085485   | 0.085485   | 0.085485   |   0.0 |  0.07
Output  | 0.00015164 | 0.00015164 | 0.00015164 |   0.0 |  0.00
Modify  | 0.34653    | 0.34653    | 0.34653    |   0.0 |  0.29
Other   |            | 0.0541     |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3197.00 ave        3197 max        3197 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119258.0 ave      119258 max      119258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119258
Ave neighs/atom = 59.629000
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.505735865671, Press = 1.33774126652865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -3153.141    -3153.141   -3223.2674   -3223.2674     271.3967     271.3967    42667.473    42667.473    72.637721    72.637721 
   30000   -3153.6529   -3153.6529   -3224.4996   -3224.4996    274.18429    274.18429    42815.638    42815.638   -470.97552   -470.97552 
Loop time of 121.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.678 hours/ns, 8.248 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.31     | 120.31     | 120.31     |   0.0 | 99.23
Neigh   | 0.44475    | 0.44475    | 0.44475    |   0.0 |  0.37
Comm    | 0.084793   | 0.084793   | 0.084793   |   0.0 |  0.07
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.34777    | 0.34777    | 0.34777    |   0.0 |  0.29
Other   |            | 0.05438    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3160.00 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119030.0 ave      119030 max      119030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119030
Ave neighs/atom = 59.515000
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.534027053353, Press = -1.28423170048901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -3153.6529   -3153.6529   -3224.4996   -3224.4996    274.18429    274.18429    42815.638    42815.638   -470.97552   -470.97552 
   31000   -3149.7541   -3149.7541    -3220.902    -3220.902     275.3499     275.3499    42758.101    42758.101   -115.02983   -115.02983 
Loop time of 121.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.816 hours/ns, 8.214 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.78     | 120.78     | 120.78     |   0.0 | 99.21
Neigh   | 0.47276    | 0.47276    | 0.47276    |   0.0 |  0.39
Comm    | 0.085696   | 0.085696   | 0.085696   |   0.0 |  0.07
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.34747    | 0.34747    | 0.34747    |   0.0 |  0.29
Other   |            | 0.054      |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3109.00 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119068.0 ave      119068 max      119068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119068
Ave neighs/atom = 59.534000
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.569543494148, Press = -1.67549302655714
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -3149.7541   -3149.7541    -3220.902    -3220.902     275.3499     275.3499    42758.101    42758.101   -115.02983   -115.02983 
   32000   -3151.9774   -3151.9774   -3223.6131   -3223.6131    277.23759    277.23759    42664.965    42664.965    140.21675    140.21675 
Loop time of 121.841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.845 hours/ns, 8.207 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.89     | 120.89     | 120.89     |   0.0 | 99.22
Neigh   | 0.46711    | 0.46711    | 0.46711    |   0.0 |  0.38
Comm    | 0.084829   | 0.084829   | 0.084829   |   0.0 |  0.07
Output  | 0.00014543 | 0.00014543 | 0.00014543 |   0.0 |  0.00
Modify  | 0.34688    | 0.34688    | 0.34688    |   0.0 |  0.28
Other   |            | 0.05434    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3164.00 ave        3164 max        3164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119106.0 ave      119106 max      119106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119106
Ave neighs/atom = 59.553000
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.559469613654, Press = -1.27843804071867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -3151.9774   -3151.9774   -3223.6131   -3223.6131    277.23759    277.23759    42664.965    42664.965    140.21675    140.21675 
   33000   -3157.2681   -3157.2681   -3225.2581   -3225.2581    263.12841    263.12841    42636.054    42636.054   -29.164919   -29.164919 
Loop time of 121.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.678 hours/ns, 8.248 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.31     | 120.31     | 120.31     |   0.0 | 99.23
Neigh   | 0.44581    | 0.44581    | 0.44581    |   0.0 |  0.37
Comm    | 0.084779   | 0.084779   | 0.084779   |   0.0 |  0.07
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.34571    | 0.34571    | 0.34571    |   0.0 |  0.29
Other   |            | 0.05314    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3130.00 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119092.0 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546000
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.486329173886, Press = -0.981824443085437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -3157.2681   -3157.2681   -3225.2581   -3225.2581    263.12841    263.12841    42636.054    42636.054   -29.164919   -29.164919 
   34000   -3152.4612   -3152.4612   -3222.8754   -3222.8754    272.51042    272.51042    42637.452    42637.452     195.4029     195.4029 
Loop time of 121.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.644 hours/ns, 8.256 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.19     | 120.19     | 120.19     |   0.0 | 99.23
Neigh   | 0.44641    | 0.44641    | 0.44641    |   0.0 |  0.37
Comm    | 0.084632   | 0.084632   | 0.084632   |   0.0 |  0.07
Output  | 0.00018929 | 0.00018929 | 0.00018929 |   0.0 |  0.00
Modify  | 0.34568    | 0.34568    | 0.34568    |   0.0 |  0.29
Other   |            | 0.05319    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3157.00 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119188.0 ave      119188 max      119188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119188
Ave neighs/atom = 59.594000
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.46285533533, Press = -0.250602798917864
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -3152.4612   -3152.4612   -3222.8754   -3222.8754    272.51042    272.51042    42637.452    42637.452     195.4029     195.4029 
   35000   -3152.1273   -3152.1273   -3222.2415   -3222.2415    271.34955    271.34955    42894.657    42894.657   -542.25146   -542.25146 
Loop time of 120.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.539 hours/ns, 8.282 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.8      | 119.8      | 119.8      |   0.0 | 99.22
Neigh   | 0.46466    | 0.46466    | 0.46466    |   0.0 |  0.38
Comm    | 0.084688   | 0.084688   | 0.084688   |   0.0 |  0.07
Output  | 0.00015231 | 0.00015231 | 0.00015231 |   0.0 |  0.00
Modify  | 0.34345    | 0.34345    | 0.34345    |   0.0 |  0.28
Other   |            | 0.05321    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3091.00 ave        3091 max        3091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118988.0 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494000
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.434426901018, Press = 0.318575649363781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -3152.1273   -3152.1273   -3222.2415   -3222.2415    271.34955    271.34955    42894.657    42894.657   -542.25146   -542.25146 
   36000   -3153.6861   -3153.6861    -3224.557    -3224.557    274.27771    274.27771    42805.823    42805.823   -338.06709   -338.06709 
Loop time of 120.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.536 hours/ns, 8.283 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.76     | 119.76     | 119.76     |   0.0 | 99.20
Neigh   | 0.48642    | 0.48642    | 0.48642    |   0.0 |  0.40
Comm    | 0.084617   | 0.084617   | 0.084617   |   0.0 |  0.07
Output  | 0.00015313 | 0.00015313 | 0.00015313 |   0.0 |  0.00
Modify  | 0.34327    | 0.34327    | 0.34327    |   0.0 |  0.28
Other   |            | 0.05374    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3181.00 ave        3181 max        3181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119020.0 ave      119020 max      119020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119020
Ave neighs/atom = 59.510000
Neighbor list builds = 23
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.453439623751, Press = -1.54242440759279
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -3153.6861   -3153.6861    -3224.557    -3224.557    274.27771    274.27771    42805.823    42805.823   -338.06709   -338.06709 
   37000   -3154.6085   -3154.6085    -3224.506    -3224.506    270.51061    270.51061    42587.319    42587.319    260.01633    260.01633 
Loop time of 121.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.818 hours/ns, 8.214 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.81     | 120.81     | 120.81     |   0.0 | 99.23
Neigh   | 0.44655    | 0.44655    | 0.44655    |   0.0 |  0.37
Comm    | 0.085579   | 0.085579   | 0.085579   |   0.0 |  0.07
Output  | 0.00014666 | 0.00014666 | 0.00014666 |   0.0 |  0.00
Modify  | 0.34658    | 0.34658    | 0.34658    |   0.0 |  0.28
Other   |            | 0.05391    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3127.00 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119202.0 ave      119202 max      119202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119202
Ave neighs/atom = 59.601000
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.371561724345, Press = -0.938573559318544
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -3154.6085   -3154.6085    -3224.506    -3224.506    270.51061    270.51061    42587.319    42587.319    260.01633    260.01633 
   38000   -3153.2976   -3153.2976    -3223.139    -3223.139     270.2933     270.2933    42606.114    42606.114    261.32397    261.32397 
Loop time of 120.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.490 hours/ns, 8.294 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.64     | 119.64     | 119.64     |   0.0 | 99.23
Neigh   | 0.44026    | 0.44026    | 0.44026    |   0.0 |  0.37
Comm    | 0.084736   | 0.084736   | 0.084736   |   0.0 |  0.07
Output  | 0.00017951 | 0.00017951 | 0.00017951 |   0.0 |  0.00
Modify  | 0.34387    | 0.34387    | 0.34387    |   0.0 |  0.29
Other   |            | 0.05377    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3167.00 ave        3167 max        3167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119154.0 ave      119154 max      119154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119154
Ave neighs/atom = 59.577000
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.331526836936, Press = -0.477947819106352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -3153.2976   -3153.2976    -3223.139    -3223.139     270.2933     270.2933    42606.114    42606.114    261.32397    261.32397 
   39000   -3154.3494   -3154.3494   -3224.8666   -3224.8666    272.90857    272.90857    42844.212    42844.212   -484.56845   -484.56845 
Loop time of 121.033 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.620 hours/ns, 8.262 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.11     | 120.11     | 120.11     |   0.0 | 99.24
Neigh   | 0.43926    | 0.43926    | 0.43926    |   0.0 |  0.36
Comm    | 0.085495   | 0.085495   | 0.085495   |   0.0 |  0.07
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.34595    | 0.34595    | 0.34595    |   0.0 |  0.29
Other   |            | 0.05428    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3121.00 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119000.0 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.500000
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.283237762465, Press = -0.468289262477334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -3154.3494   -3154.3494   -3224.8666   -3224.8666    272.90857    272.90857    42844.212    42844.212   -484.56845   -484.56845 
   40000   -3148.3688   -3148.3688   -3221.4099   -3221.4099    282.67642    282.67642    42755.181    42755.181   -25.284003   -25.284003 
Loop time of 120.708 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.530 hours/ns, 8.284 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.76     | 119.76     | 119.76     |   0.0 | 99.21
Neigh   | 0.46605    | 0.46605    | 0.46605    |   0.0 |  0.39
Comm    | 0.084658   | 0.084658   | 0.084658   |   0.0 |  0.07
Output  | 0.0001837  | 0.0001837  | 0.0001837  |   0.0 |  0.00
Modify  | 0.34526    | 0.34526    | 0.34526    |   0.0 |  0.29
Other   |            | 0.05469    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3168.00 ave        3168 max        3168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118990.0 ave      118990 max      118990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118990
Ave neighs/atom = 59.495000
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.311712458249, Press = -1.97167533428913
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -3148.3688   -3148.3688   -3221.4099   -3221.4099    282.67642    282.67642    42755.181    42755.181   -25.284003   -25.284003 
   41000   -3155.9835   -3155.9835   -3224.5949   -3224.5949    265.53319    265.53319    42467.688    42467.688    602.67751    602.67751 
Loop time of 120.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.582 hours/ns, 8.272 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.94     | 119.94     | 119.94     |   0.0 | 99.21
Neigh   | 0.4667     | 0.4667     | 0.4667     |   0.0 |  0.39
Comm    | 0.085735   | 0.085735   | 0.085735   |   0.0 |  0.07
Output  | 0.0004322  | 0.0004322  | 0.0004322  |   0.0 |  0.00
Modify  | 0.3466     | 0.3466     | 0.3466     |   0.0 |  0.29
Other   |            | 0.05425    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3118.00 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119274.0 ave      119274 max      119274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119274
Ave neighs/atom = 59.637000
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.330151380351, Press = -1.11810551650655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -3155.9835   -3155.9835   -3224.5949   -3224.5949    265.53319    265.53319    42467.688    42467.688    602.67751    602.67751 
   42000   -3152.0815   -3152.0815   -3222.3007   -3222.3007    271.75539    271.75539    42712.741    42712.741    11.025812    11.025812 
Loop time of 121.015 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.615 hours/ns, 8.263 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.06     | 120.06     | 120.06     |   0.0 | 99.21
Neigh   | 0.46823    | 0.46823    | 0.46823    |   0.0 |  0.39
Comm    | 0.084156   | 0.084156   | 0.084156   |   0.0 |  0.07
Output  | 0.00015172 | 0.00015172 | 0.00015172 |   0.0 |  0.00
Modify  | 0.34746    | 0.34746    | 0.34746    |   0.0 |  0.29
Other   |            | 0.05451    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3170.00 ave        3170 max        3170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119262.0 ave      119262 max      119262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119262
Ave neighs/atom = 59.631000
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"
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
42696.4295235991

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0