# 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.165197603404522*${_u_distance}
variable latticeconst_converted equal 3.165197603404522*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.16519760340452
Lattice spacing in x,y,z = 3.1651976 3.1651976 3.1651976
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 (31.651976 31.651976 31.651976)
  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 (31.651976 31.651976 31.651976)
  create_atoms CPU = 0.003 seconds

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

kim_interactions W

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

kim interactions W
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_MasonNguyenManhBecquart_2017_W__MO_268730733493_000
pair_coeff * * W
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 183.84

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31710.4558090515 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_268730733493_000#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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17724.257   -17724.257   -17800.004   -17800.004       293.15       293.15    31710.456    31710.456    2551.4525    2551.4525 
    1000   -17646.468   -17646.468    -17718.88    -17718.88    280.24158    280.24158    31819.322    31819.322   -166.42138   -166.42138 
Loop time of 10.6802 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.090 ns/day, 2.967 hours/ns, 93.631 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 10.12      | 10.12      | 10.12      |   0.0 | 94.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10773    | 0.10773    | 0.10773    |   0.0 |  1.01
Output  | 0.00020267 | 0.00020267 | 0.00020267 |   0.0 |  0.00
Modify  | 0.3863     | 0.3863     | 0.3863     |   0.0 |  3.62
Other   |            | 0.06596    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17646.468   -17646.468    -17718.88    -17718.88    280.24158    280.24158    31819.322    31819.322   -166.42138   -166.42138 
    2000   -17646.072   -17646.072   -17717.856   -17717.856    277.81154    277.81154    31828.893    31828.893   -276.86075   -276.86075 
Loop time of 10.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.035 ns/day, 2.987 hours/ns, 92.997 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    | 10.203     | 10.203     | 10.203     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10309    | 0.10309    | 0.10309    |   0.0 |  0.96
Output  | 0.00019158 | 0.00019158 | 0.00019158 |   0.0 |  0.00
Modify  | 0.38113    | 0.38113    | 0.38113    |   0.0 |  3.54
Other   |            | 0.06547    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4040.00 ave        4040 max        4040 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:      126152.0 ave      126152 max      126152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126152
Ave neighs/atom = 63.076000
Neighbor list builds = 0
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17646.072   -17646.072   -17717.856   -17717.856    277.81154    277.81154    31828.893    31828.893   -276.86075   -276.86075 
    3000   -17648.034   -17648.034   -17726.814   -17726.814    304.88461    304.88461    31820.082    31820.082   -359.98397   -359.98397 
Loop time of 10.5238 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.210 ns/day, 2.923 hours/ns, 95.023 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    | 9.9885     | 9.9885     | 9.9885     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10306    | 0.10306    | 0.10306    |   0.0 |  0.98
Output  | 0.00019126 | 0.00019126 | 0.00019126 |   0.0 |  0.00
Modify  | 0.3688     | 0.3688     | 0.3688     |   0.0 |  3.50
Other   |            | 0.06319    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4028.00 ave        4028 max        4028 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:      125980.0 ave      125980 max      125980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125980
Ave neighs/atom = 62.990000
Neighbor list builds = 0
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17648.034   -17648.034   -17726.814   -17726.814    304.88461    304.88461    31820.082    31820.082   -359.98397   -359.98397 
    4000   -17644.835   -17644.835   -17723.027   -17723.027    302.61336    302.61336    31782.067    31782.067    2642.7179    2642.7179 
Loop time of 10.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.476 ns/day, 2.832 hours/ns, 98.097 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    | 9.6881     | 9.6881     | 9.6881     |   0.0 | 95.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098164   | 0.098164   | 0.098164   |   0.0 |  0.96
Output  | 0.00027593 | 0.00027593 | 0.00027593 |   0.0 |  0.00
Modify  | 0.34619    | 0.34619    | 0.34619    |   0.0 |  3.40
Other   |            | 0.06129    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4009.00 ave        4009 max        4009 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:      126446.0 ave      126446 max      126446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126446
Ave neighs/atom = 63.223000
Neighbor list builds = 0
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17644.835   -17644.835   -17723.027   -17723.027    302.61336    302.61336    31782.067    31782.067    2642.7179    2642.7179 
    5000   -17647.835   -17647.835   -17724.146   -17724.146    295.33171    295.33171    31802.375    31802.375    1181.2554    1181.2554 
Loop time of 10.1872 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.481 ns/day, 2.830 hours/ns, 98.163 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    | 9.6814     | 9.6814     | 9.6814     |   0.0 | 95.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095804   | 0.095804   | 0.095804   |   0.0 |  0.94
Output  | 0.00019758 | 0.00019758 | 0.00019758 |   0.0 |  0.00
Modify  | 0.34853    | 0.34853    | 0.34853    |   0.0 |  3.42
Other   |            | 0.06125    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4013.00 ave        4013 max        4013 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:      126234.0 ave      126234 max      126234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126234
Ave neighs/atom = 63.117000
Neighbor list builds = 0
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 = 292.806126992587, Press = -134.786943421513
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17647.835   -17647.835   -17724.146   -17724.146    295.33171    295.33171    31802.375    31802.375    1181.2554    1181.2554 
    6000   -17645.717   -17645.717   -17719.877   -17719.877    287.00658    287.00658    31804.258    31804.258    1230.9768    1230.9768 
Loop time of 10.2371 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.440 ns/day, 2.844 hours/ns, 97.684 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    | 9.7153     | 9.7153     | 9.7153     |   0.0 | 94.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096014   | 0.096014   | 0.096014   |   0.0 |  0.94
Output  | 0.00015111 | 0.00015111 | 0.00015111 |   0.0 |  0.00
Modify  | 0.36376    | 0.36376    | 0.36376    |   0.0 |  3.55
Other   |            | 0.06185    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4013.00 ave        4013 max        4013 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:      126326.0 ave      126326 max      126326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126326
Ave neighs/atom = 63.163000
Neighbor list builds = 0
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 = 291.978429703298, Press = 10.6676230241935
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17645.717   -17645.717   -17719.877   -17719.877    287.00658    287.00658    31804.258    31804.258    1230.9768    1230.9768 
    7000   -17651.347   -17651.347   -17724.359   -17724.359    282.56192    282.56192    31822.508    31822.508   -1000.6734   -1000.6734 
Loop time of 10.0956 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.558 ns/day, 2.804 hours/ns, 99.053 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    | 9.5797     | 9.5797     | 9.5797     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095835   | 0.095835   | 0.095835   |   0.0 |  0.95
Output  | 0.00020076 | 0.00020076 | 0.00020076 |   0.0 |  0.00
Modify  | 0.35802    | 0.35802    | 0.35802    |   0.0 |  3.55
Other   |            | 0.06186    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4013.00 ave        4013 max        4013 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:      126196.0 ave      126196 max      126196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126196
Ave neighs/atom = 63.098000
Neighbor list builds = 0
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 = 292.334158662574, Press = 10.5630002632704
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17651.347   -17651.347   -17724.359   -17724.359    282.56192    282.56192    31822.508    31822.508   -1000.6734   -1000.6734 
    8000   -17645.402   -17645.402   -17721.024   -17721.024    292.66316    292.66316    31783.875    31783.875    2784.5032    2784.5032 
Loop time of 10.4028 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.305 ns/day, 2.890 hours/ns, 96.128 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    | 9.8682     | 9.8682     | 9.8682     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097559   | 0.097559   | 0.097559   |   0.0 |  0.94
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.37487    | 0.37487    | 0.37487    |   0.0 |  3.60
Other   |            | 0.06205    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4016.00 ave        4016 max        4016 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:      126174.0 ave      126174 max      126174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126174
Ave neighs/atom = 63.087000
Neighbor list builds = 0
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 = 292.333515345716, Press = 4.20365719635592
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17645.402   -17645.402   -17721.024   -17721.024    292.66316    292.66316    31783.875    31783.875    2784.5032    2784.5032 
    9000   -17648.314   -17648.314   -17723.205   -17723.205    289.83587    289.83587    31743.557    31743.557    6057.9757    6057.9757 
Loop time of 10.2238 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.451 ns/day, 2.840 hours/ns, 97.811 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    | 9.697      | 9.697      | 9.697      |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097635   | 0.097635   | 0.097635   |   0.0 |  0.95
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.36673    | 0.36673    | 0.36673    |   0.0 |  3.59
Other   |            | 0.06233    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4005.00 ave        4005 max        4005 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:      126218.0 ave      126218 max      126218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126218
Ave neighs/atom = 63.109000
Neighbor list builds = 0
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 = 292.232851758049, Press = 6.43262235203322
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17648.314   -17648.314   -17723.205   -17723.205    289.83587    289.83587    31743.557    31743.557    6057.9757    6057.9757 
   10000   -17649.434   -17649.434   -17722.683   -17722.683    283.48057    283.48057    31804.818    31804.818    688.86654    688.86654 
Loop time of 10.4157 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.295 ns/day, 2.893 hours/ns, 96.009 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    | 9.8809     | 9.8809     | 9.8809     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099084   | 0.099084   | 0.099084   |   0.0 |  0.95
Output  | 0.00015251 | 0.00015251 | 0.00015251 |   0.0 |  0.00
Modify  | 0.37251    | 0.37251    | 0.37251    |   0.0 |  3.58
Other   |            | 0.06311    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4018.00 ave        4018 max        4018 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:      126314.0 ave      126314 max      126314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126314
Ave neighs/atom = 63.157000
Neighbor list builds = 0
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 = 291.978743775605, Press = 10.6194454920832
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17649.434   -17649.434   -17722.683   -17722.683    283.48057    283.48057    31804.818    31804.818    688.86654    688.86654 
   11000   -17647.391   -17647.391   -17724.155   -17724.155    297.08455    297.08455    31850.835    31850.835   -3487.2944   -3487.2944 
Loop time of 10.4505 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.268 ns/day, 2.903 hours/ns, 95.689 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    | 9.9118     | 9.9118     | 9.9118     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098394   | 0.098394   | 0.098394   |   0.0 |  0.94
Output  | 0.00019251 | 0.00019251 | 0.00019251 |   0.0 |  0.00
Modify  | 0.3773     | 0.3773     | 0.3773     |   0.0 |  3.61
Other   |            | 0.06277    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4016.00 ave        4016 max        4016 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:      126248.0 ave      126248 max      126248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126248
Ave neighs/atom = 63.124000
Neighbor list builds = 0
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 = 292.015150607783, Press = 3.11227767725521
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17647.391   -17647.391   -17724.155   -17724.155    297.08455    297.08455    31850.835    31850.835   -3487.2944   -3487.2944 
   12000   -17647.961   -17647.961   -17723.271   -17723.271    291.45699    291.45699     31794.02     31794.02    1702.5442    1702.5442 
Loop time of 9.95656 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.678 ns/day, 2.766 hours/ns, 100.436 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    | 9.446      | 9.446      | 9.446      |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093625   | 0.093625   | 0.093625   |   0.0 |  0.94
Output  | 0.00014955 | 0.00014955 | 0.00014955 |   0.0 |  0.00
Modify  | 0.35514    | 0.35514    | 0.35514    |   0.0 |  3.57
Other   |            | 0.06164    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3991.00 ave        3991 max        3991 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:      126174.0 ave      126174 max      126174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126174
Ave neighs/atom = 63.087000
Neighbor list builds = 0
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 = 291.961905959265, Press = 1.0007643483899
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17647.961   -17647.961   -17723.271   -17723.271    291.45699    291.45699     31794.02     31794.02    1702.5442    1702.5442 
   13000    -17641.01    -17641.01   -17719.836   -17719.836    305.06529    305.06529    31824.307    31824.307   -572.81235   -572.81235 
Loop time of 10.0995 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.555 ns/day, 2.805 hours/ns, 99.015 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    | 9.5819     | 9.5819     | 9.5819     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096667   | 0.096667   | 0.096667   |   0.0 |  0.96
Output  | 0.00015122 | 0.00015122 | 0.00015122 |   0.0 |  0.00
Modify  | 0.35941    | 0.35941    | 0.35941    |   0.0 |  3.56
Other   |            | 0.06131    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4012.00 ave        4012 max        4012 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:      126304.0 ave      126304 max      126304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126304
Ave neighs/atom = 63.152000
Neighbor list builds = 0
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 = 292.374449072232, Press = 2.08561565056183
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -17641.01    -17641.01   -17719.836   -17719.836    305.06529    305.06529    31824.307    31824.307   -572.81235   -572.81235 
   14000   -17645.966   -17645.966   -17722.309   -17722.309    295.45452    295.45452    31797.523    31797.523    1355.7269    1355.7269 
Loop time of 10.4805 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.244 ns/day, 2.911 hours/ns, 95.415 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    | 9.9394     | 9.9394     | 9.9394     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099149   | 0.099149   | 0.099149   |   0.0 |  0.95
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.37954    | 0.37954    | 0.37954    |   0.0 |  3.62
Other   |            | 0.06228    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3958.00 ave        3958 max        3958 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:      126098.0 ave      126098 max      126098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126098
Ave neighs/atom = 63.049000
Neighbor list builds = 0
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 = 292.48945321967, Press = 1.28675819301223
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17645.966   -17645.966   -17722.309   -17722.309    295.45452    295.45452    31797.523    31797.523    1355.7269    1355.7269 
   15000   -17646.956   -17646.956   -17723.459   -17723.459    296.07667    296.07667    31759.217    31759.217    5054.4264    5054.4264 
Loop time of 10.1745 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.492 ns/day, 2.826 hours/ns, 98.285 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    | 9.6543     | 9.6543     | 9.6543     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096474   | 0.096474   | 0.096474   |   0.0 |  0.95
Output  | 0.00015662 | 0.00015662 | 0.00015662 |   0.0 |  0.00
Modify  | 0.36157    | 0.36157    | 0.36157    |   0.0 |  3.55
Other   |            | 0.06201    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4035.00 ave        4035 max        4035 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:      126312.0 ave      126312 max      126312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126312
Ave neighs/atom = 63.156000
Neighbor list builds = 0
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 = 292.548537765973, Press = 11.1684252569946
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17646.956   -17646.956   -17723.459   -17723.459    296.07667    296.07667    31759.217    31759.217    5054.4264    5054.4264 
   16000   -17646.985   -17646.985   -17721.424   -17721.424     288.0838     288.0838    31817.147    31817.147   -478.39654   -478.39654 
Loop time of 9.9525 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.681 ns/day, 2.765 hours/ns, 100.477 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    | 9.4402     | 9.4402     | 9.4402     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095468   | 0.095468   | 0.095468   |   0.0 |  0.96
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.35555    | 0.35555    | 0.35555    |   0.0 |  3.57
Other   |            | 0.06108    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4031.00 ave        4031 max        4031 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:      126434.0 ave      126434 max      126434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126434
Ave neighs/atom = 63.217000
Neighbor list builds = 0
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 = 292.577975063977, Press = 6.75237635045487
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17646.985   -17646.985   -17721.424   -17721.424     288.0838     288.0838    31817.147    31817.147   -478.39654   -478.39654 
   17000   -17649.194   -17649.194   -17723.231   -17723.231    286.53361    286.53361    31819.687    31819.687   -875.85964   -875.85964 
Loop time of 10.9539 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.888 ns/day, 3.043 hours/ns, 91.291 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    | 10.387     | 10.387     | 10.387     |   0.0 | 94.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10403    | 0.10403    | 0.10403    |   0.0 |  0.95
Output  | 0.00019578 | 0.00019578 | 0.00019578 |   0.0 |  0.00
Modify  | 0.39781    | 0.39781    | 0.39781    |   0.0 |  3.63
Other   |            | 0.06447    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4024.00 ave        4024 max        4024 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:      126134.0 ave      126134 max      126134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126134
Ave neighs/atom = 63.067000
Neighbor list builds = 0
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 = 292.630652064496, Press = 2.7783001153574
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17649.194   -17649.194   -17723.231   -17723.231    286.53361    286.53361    31819.687    31819.687   -875.85964   -875.85964 
   18000   -17646.694   -17646.694   -17723.289   -17723.289    296.43082    296.43082    31818.581    31818.581   -760.36134   -760.36134 
Loop time of 10.8891 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.935 ns/day, 3.025 hours/ns, 91.835 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    | 10.322     | 10.322     | 10.322     |   0.0 | 94.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10266    | 0.10266    | 0.10266    |   0.0 |  0.94
Output  | 0.00015766 | 0.00015766 | 0.00015766 |   0.0 |  0.00
Modify  | 0.39958    | 0.39958    | 0.39958    |   0.0 |  3.67
Other   |            | 0.06436    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3993.00 ave        3993 max        3993 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:      126234.0 ave      126234 max      126234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126234
Ave neighs/atom = 63.117000
Neighbor list builds = 0
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 = 292.638063439465, Press = 2.71731356118255
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17646.694   -17646.694   -17723.289   -17723.289    296.43082    296.43082    31818.581    31818.581   -760.36134   -760.36134 
   19000   -17648.068   -17648.068   -17724.479   -17724.479     295.7153     295.7153     31828.33     31828.33   -1487.6687   -1487.6687 
Loop time of 9.962 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.673 ns/day, 2.767 hours/ns, 100.381 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    | 9.4502     | 9.4502     | 9.4502     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094788   | 0.094788   | 0.094788   |   0.0 |  0.95
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.35532    | 0.35532    | 0.35532    |   0.0 |  3.57
Other   |            | 0.06156    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4030.00 ave        4030 max        4030 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:      126158.0 ave      126158 max      126158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126158
Ave neighs/atom = 63.079000
Neighbor list builds = 0
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 = 292.719513540643, Press = -0.506181928009546
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17648.068   -17648.068   -17724.479   -17724.479     295.7153     295.7153     31828.33     31828.33   -1487.6687   -1487.6687 
   20000   -17645.019   -17645.019     -17721.1     -17721.1    294.44258    294.44258    31756.861    31756.861    5733.8266    5733.8266 
Loop time of 10.0502 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.597 ns/day, 2.792 hours/ns, 99.501 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    | 9.5349     | 9.5349     | 9.5349     |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096074   | 0.096074   | 0.096074   |   0.0 |  0.96
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.35753    | 0.35753    | 0.35753    |   0.0 |  3.56
Other   |            | 0.06156    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 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:      126242.0 ave      126242 max      126242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126242
Ave neighs/atom = 63.121000
Neighbor list builds = 0
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 = 292.667097319672, Press = 2.89953723911924
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17645.019   -17645.019     -17721.1     -17721.1    294.44258    294.44258    31756.861    31756.861    5733.8266    5733.8266 
   21000   -17650.143   -17650.143   -17724.305   -17724.305    287.01655    287.01655    31789.977    31789.977    1747.5395    1747.5395 
Loop time of 10.3973 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.310 ns/day, 2.888 hours/ns, 96.179 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    | 9.8732     | 9.8732     | 9.8732     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10014    | 0.10014    | 0.10014    |   0.0 |  0.96
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.3626     | 0.3626     | 0.3626     |   0.0 |  3.49
Other   |            | 0.06118    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4054.00 ave        4054 max        4054 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:      126454.0 ave      126454 max      126454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126454
Ave neighs/atom = 63.227000
Neighbor list builds = 0
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 = 292.578062796875, Press = 4.88125481323895
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17650.143   -17650.143   -17724.305   -17724.305    287.01655    287.01655    31789.977    31789.977    1747.5395    1747.5395 
   22000   -17645.556   -17645.556   -17720.336   -17720.336    289.40435    289.40435    31814.682    31814.682    265.27732    265.27732 
Loop time of 10.2609 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.420 ns/day, 2.850 hours/ns, 97.458 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    | 9.7385     | 9.7385     | 9.7385     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096687   | 0.096687   | 0.096687   |   0.0 |  0.94
Output  | 0.00015763 | 0.00015763 | 0.00015763 |   0.0 |  0.00
Modify  | 0.363      | 0.363      | 0.363      |   0.0 |  3.54
Other   |            | 0.06257    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4004.00 ave        4004 max        4004 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:      126322.0 ave      126322 max      126322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126322
Ave neighs/atom = 63.161000
Neighbor list builds = 0
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 = 292.457377403013, Press = 5.553443617213
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17645.556   -17645.556   -17720.336   -17720.336    289.40435    289.40435    31814.682    31814.682    265.27732    265.27732 
   23000   -17648.863   -17648.863    -17721.35    -17721.35    280.53078    280.53078    31827.019    31827.019   -1410.8843   -1410.8843 
Loop time of 10.0362 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.609 ns/day, 2.788 hours/ns, 99.639 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    | 9.521      | 9.521      | 9.521      |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095157   | 0.095157   | 0.095157   |   0.0 |  0.95
Output  | 0.00015615 | 0.00015615 | 0.00015615 |   0.0 |  0.00
Modify  | 0.35767    | 0.35767    | 0.35767    |   0.0 |  3.56
Other   |            | 0.06224    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4011.00 ave        4011 max        4011 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:      126220.0 ave      126220 max      126220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126220
Ave neighs/atom = 63.110000
Neighbor list builds = 0
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 = 292.421233936596, Press = 2.74794086996303
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17648.863   -17648.863    -17721.35    -17721.35    280.53078    280.53078    31827.019    31827.019   -1410.8843   -1410.8843 
   24000   -17647.097   -17647.097   -17723.064   -17723.064    294.00084    294.00084    31813.035    31813.035   -92.415961   -92.415961 
Loop time of 10.3647 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.336 ns/day, 2.879 hours/ns, 96.481 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    | 9.8305     | 9.8305     | 9.8305     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099165   | 0.099165   | 0.099165   |   0.0 |  0.96
Output  | 0.00015965 | 0.00015965 | 0.00015965 |   0.0 |  0.00
Modify  | 0.37187    | 0.37187    | 0.37187    |   0.0 |  3.59
Other   |            | 0.063      |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 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:      126160.0 ave      126160 max      126160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126160
Ave neighs/atom = 63.080000
Neighbor list builds = 0
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 = 292.568804984879, Press = 1.81276546583692
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17647.097   -17647.097   -17723.064   -17723.064    294.00084    294.00084    31813.035    31813.035   -92.415961   -92.415961 
   25000   -17645.134   -17645.134   -17722.814   -17722.814    300.62901    300.62901    31797.084    31797.084    1721.1551    1721.1551 
Loop time of 10.0097 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.632 ns/day, 2.780 hours/ns, 99.903 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    | 9.4932     | 9.4932     | 9.4932     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097026   | 0.097026   | 0.097026   |   0.0 |  0.97
Output  | 0.00020045 | 0.00020045 | 0.00020045 |   0.0 |  0.00
Modify  | 0.35718    | 0.35718    | 0.35718    |   0.0 |  3.57
Other   |            | 0.06211    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4042.00 ave        4042 max        4042 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:      126202.0 ave      126202 max      126202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126202
Ave neighs/atom = 63.101000
Neighbor list builds = 0
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 = 292.543613999551, Press = 3.07346748658227
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17645.134   -17645.134   -17722.814   -17722.814    300.62901    300.62901    31797.084    31797.084    1721.1551    1721.1551 
   26000   -17651.301   -17651.301   -17725.622   -17725.622     287.6301     287.6301    31805.214    31805.214     179.6545     179.6545 
Loop time of 11.0239 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.838 ns/day, 3.062 hours/ns, 90.712 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    | 10.459     | 10.459     | 10.459     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10368    | 0.10368    | 0.10368    |   0.0 |  0.94
Output  | 0.00019485 | 0.00019485 | 0.00019485 |   0.0 |  0.00
Modify  | 0.39577    | 0.39577    | 0.39577    |   0.0 |  3.59
Other   |            | 0.06485    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4034.00 ave        4034 max        4034 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:      126256.0 ave      126256 max      126256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126256
Ave neighs/atom = 63.128000
Neighbor list builds = 0
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 = 292.472689632465, Press = 1.47702182565394
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17651.301   -17651.301   -17725.622   -17725.622     287.6301     287.6301    31805.214    31805.214     179.6545     179.6545 
   27000   -17644.868   -17644.868   -17721.595   -17721.595    296.94417    296.94417     31829.59     31829.59   -1182.4303   -1182.4303 
Loop time of 10.0432 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.603 ns/day, 2.790 hours/ns, 99.570 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    | 9.5271     | 9.5271     | 9.5271     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095685   | 0.095685   | 0.095685   |   0.0 |  0.95
Output  | 0.00020281 | 0.00020281 | 0.00020281 |   0.0 |  0.00
Modify  | 0.35903    | 0.35903    | 0.35903    |   0.0 |  3.57
Other   |            | 0.06116    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4046.00 ave        4046 max        4046 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:      126348.0 ave      126348 max      126348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126348
Ave neighs/atom = 63.174000
Neighbor list builds = 0
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 = 292.455655060492, Press = 2.2724657203831
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17644.868   -17644.868   -17721.595   -17721.595    296.94417    296.94417     31829.59     31829.59   -1182.4303   -1182.4303 
   28000   -17647.938   -17647.938     -17722.7     -17722.7    289.33898    289.33898    31831.394    31831.394   -1596.8243   -1596.8243 
Loop time of 10.5155 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.216 ns/day, 2.921 hours/ns, 95.097 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    | 9.9724     | 9.9724     | 9.9724     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099597   | 0.099597   | 0.099597   |   0.0 |  0.95
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  3.62
Other   |            | 0.06276    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4015.00 ave        4015 max        4015 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:      126218.0 ave      126218 max      126218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126218
Ave neighs/atom = 63.109000
Neighbor list builds = 0
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 = 292.488489325688, Press = 0.964896399798607
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17647.938   -17647.938     -17722.7     -17722.7    289.33898    289.33898    31831.394    31831.394   -1596.8243   -1596.8243 
   29000   -17644.462   -17644.462   -17721.956   -17721.956    299.90825    299.90825    31786.905    31786.905    2312.5005    2312.5005 
Loop time of 9.97783 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.659 ns/day, 2.772 hours/ns, 100.222 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    | 9.4655     | 9.4655     | 9.4655     |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095271   | 0.095271   | 0.095271   |   0.0 |  0.95
Output  | 0.00015328 | 0.00015328 | 0.00015328 |   0.0 |  0.00
Modify  | 0.35532    | 0.35532    | 0.35532    |   0.0 |  3.56
Other   |            | 0.06159    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4053.00 ave        4053 max        4053 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:      126272.0 ave      126272 max      126272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126272
Ave neighs/atom = 63.136000
Neighbor list builds = 0
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 = 292.546998946016, Press = -0.191589328204863
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17644.462   -17644.462   -17721.956   -17721.956    299.90825    299.90825    31786.905    31786.905    2312.5005    2312.5005 
   30000   -17644.289   -17644.289   -17720.995   -17720.995    296.85727    296.85727    31790.588    31790.588    2502.6597    2502.6597 
Loop time of 10.3493 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.348 ns/day, 2.875 hours/ns, 96.625 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    | 9.814      | 9.814      | 9.814      |   0.0 | 94.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098659   | 0.098659   | 0.098659   |   0.0 |  0.95
Output  | 0.00019491 | 0.00019491 | 0.00019491 |   0.0 |  0.00
Modify  | 0.37455    | 0.37455    | 0.37455    |   0.0 |  3.62
Other   |            | 0.06187    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4021.00 ave        4021 max        4021 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:      126250.0 ave      126250 max      126250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126250
Ave neighs/atom = 63.125000
Neighbor list builds = 0
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 = 292.615796543456, Press = 2.81923952186165
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17644.289   -17644.289   -17720.995   -17720.995    296.85727    296.85727    31790.588    31790.588    2502.6597    2502.6597 
   31000   -17648.527   -17648.527    -17723.33    -17723.33    289.49616    289.49616    31816.004    31816.004   -426.81652   -426.81652 
Loop time of 10.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.367 ns/day, 2.868 hours/ns, 96.843 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    | 9.79       | 9.79       | 9.79       |   0.0 | 94.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099016   | 0.099016   | 0.099016   |   0.0 |  0.96
Output  | 0.00015374 | 0.00015374 | 0.00015374 |   0.0 |  0.00
Modify  | 0.37443    | 0.37443    | 0.37443    |   0.0 |  3.63
Other   |            | 0.06239    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4007.00 ave        4007 max        4007 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:      126308.0 ave      126308 max      126308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126308
Ave neighs/atom = 63.154000
Neighbor list builds = 0
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 = 292.615417972077, Press = 2.58815444917553
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17648.527   -17648.527    -17723.33    -17723.33    289.49616    289.49616    31816.004    31816.004   -426.81652   -426.81652 
   32000   -17647.872   -17647.872   -17722.936   -17722.936    290.50366    290.50366    31819.603    31819.603    -410.5977    -410.5977 
Loop time of 10.8944 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.931 ns/day, 3.026 hours/ns, 91.790 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    | 10.334     | 10.334     | 10.334     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10203    | 0.10203    | 0.10203    |   0.0 |  0.94
Output  | 0.0001538  | 0.0001538  | 0.0001538  |   0.0 |  0.00
Modify  | 0.39358    | 0.39358    | 0.39358    |   0.0 |  3.61
Other   |            | 0.06459    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3993.00 ave        3993 max        3993 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:      126276.0 ave      126276 max      126276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126276
Ave neighs/atom = 63.138000
Neighbor list builds = 0
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 = 292.667105159395, Press = 2.01773513447514
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17647.872   -17647.872   -17722.936   -17722.936    290.50366    290.50366    31819.603    31819.603    -410.5977    -410.5977 
   33000   -17646.586   -17646.586    -17721.97    -17721.97    291.74418    291.74418    31813.508    31813.508    8.3791272    8.3791272 
Loop time of 10.0412 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.605 ns/day, 2.789 hours/ns, 99.590 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    | 9.5241     | 9.5241     | 9.5241     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097191   | 0.097191   | 0.097191   |   0.0 |  0.97
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.3583     | 0.3583     | 0.3583     |   0.0 |  3.57
Other   |            | 0.06141    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4035.00 ave        4035 max        4035 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:      126248.0 ave      126248 max      126248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126248
Ave neighs/atom = 63.124000
Neighbor list builds = 0
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 = 292.76936464223, Press = 0.260134362123787
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17646.586   -17646.586    -17721.97    -17721.97    291.74418    291.74418    31813.508    31813.508    8.3791272    8.3791272 
   34000   -17647.868   -17647.868   -17721.922   -17721.922    286.59604    286.59604    31819.392    31819.392   -330.22138   -330.22138 
Loop time of 10.3363 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.359 ns/day, 2.871 hours/ns, 96.746 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    | 9.8059     | 9.8059     | 9.8059     |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098127   | 0.098127   | 0.098127   |   0.0 |  0.95
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.36932    | 0.36932    | 0.36932    |   0.0 |  3.57
Other   |            | 0.06284    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3992.00 ave        3992 max        3992 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:      126210.0 ave      126210 max      126210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126210
Ave neighs/atom = 63.105000
Neighbor list builds = 0
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 = 292.85449080794, Press = 1.7306393473262
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17647.868   -17647.868   -17721.922   -17721.922    286.59604    286.59604    31819.392    31819.392   -330.22138   -330.22138 
   35000   -17644.698   -17644.698   -17719.301   -17719.301     288.7214     288.7214     31824.87     31824.87   -794.69727   -794.69727 
Loop time of 11.2548 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.677 ns/day, 3.126 hours/ns, 88.851 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    | 10.673     | 10.673     | 10.673     |   0.0 | 94.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10518    | 0.10518    | 0.10518    |   0.0 |  0.93
Output  | 0.00020378 | 0.00020378 | 0.00020378 |   0.0 |  0.00
Modify  | 0.4113     | 0.4113     | 0.4113     |   0.0 |  3.65
Other   |            | 0.0655     |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4036.00 ave        4036 max        4036 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:      126266.0 ave      126266 max      126266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126266
Ave neighs/atom = 63.133000
Neighbor list builds = 0
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 = 292.857257638915, Press = -0.7950438853759
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17644.698   -17644.698   -17719.301   -17719.301     288.7214     288.7214     31824.87     31824.87   -794.69727   -794.69727 
   36000   -17647.071   -17647.071   -17723.272   -17723.272    294.90465    294.90465    31797.807    31797.807    931.30528    931.30528 
Loop time of 10.2082 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.464 ns/day, 2.836 hours/ns, 97.961 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    | 9.6808     | 9.6808     | 9.6808     |   0.0 | 94.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097694   | 0.097694   | 0.097694   |   0.0 |  0.96
Output  | 0.00015186 | 0.00015186 | 0.00015186 |   0.0 |  0.00
Modify  | 0.36717    | 0.36717    | 0.36717    |   0.0 |  3.60
Other   |            | 0.06234    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 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:      126078.0 ave      126078 max      126078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126078
Ave neighs/atom = 63.039000
Neighbor list builds = 0
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 = 292.920382726724, Press = 0.2051794029477
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17647.071   -17647.071   -17723.272   -17723.272    294.90465    294.90465    31797.807    31797.807    931.30528    931.30528 
   37000   -17647.841   -17647.841   -17721.936   -17721.936    286.75317    286.75317    31786.692    31786.692    2642.9437    2642.9437 
Loop time of 10.1773 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.490 ns/day, 2.827 hours/ns, 98.258 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    | 9.6483     | 9.6483     | 9.6483     |   0.0 | 94.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097996   | 0.097996   | 0.097996   |   0.0 |  0.96
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.36786    | 0.36786    | 0.36786    |   0.0 |  3.61
Other   |            | 0.06294    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4034.00 ave        4034 max        4034 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:      126328.0 ave      126328 max      126328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126328
Ave neighs/atom = 63.164000
Neighbor list builds = 0
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 = 292.998725940508, Press = 2.45321995061396
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17647.841   -17647.841   -17721.936   -17721.936    286.75317    286.75317    31786.692    31786.692    2642.9437    2642.9437 
   38000   -17646.818   -17646.818   -17721.499   -17721.499    289.02159    289.02159    31805.579    31805.579    703.88526    703.88526 
Loop time of 11.3225 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.631 ns/day, 3.145 hours/ns, 88.319 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    | 10.742     | 10.742     | 10.742     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10576    | 0.10576    | 0.10576    |   0.0 |  0.93
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.40971    | 0.40971    | 0.40971    |   0.0 |  3.62
Other   |            | 0.0646     |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4012.00 ave        4012 max        4012 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:      126352.0 ave      126352 max      126352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126352
Ave neighs/atom = 63.176000
Neighbor list builds = 0
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 = 293.015979515441, Press = 0.906297766582038
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17646.818   -17646.818   -17721.499   -17721.499    289.02159    289.02159    31805.579    31805.579    703.88526    703.88526 
   39000   -17649.925   -17649.925   -17723.719   -17723.719    285.59028    285.59028    31791.259    31791.259    1941.4881    1941.4881 
Loop time of 10.0119 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.630 ns/day, 2.781 hours/ns, 99.881 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    | 9.4983     | 9.4983     | 9.4983     |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095026   | 0.095026   | 0.095026   |   0.0 |  0.95
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.35643    | 0.35643    | 0.35643    |   0.0 |  3.56
Other   |            | 0.06197    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 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:      126172.0 ave      126172 max      126172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126172
Ave neighs/atom = 63.086000
Neighbor list builds = 0
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 = 293.009518436602, Press = 1.29669126093281
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17649.925   -17649.925   -17723.719   -17723.719    285.59028    285.59028    31791.259    31791.259    1941.4881    1941.4881 
   40000   -17645.092   -17645.092   -17721.399   -17721.399    295.31428    295.31428     31825.89     31825.89   -1156.7348   -1156.7348 
Loop time of 10.0595 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.589 ns/day, 2.794 hours/ns, 99.409 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    | 9.5399     | 9.5399     | 9.5399     |   0.0 | 94.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096044   | 0.096044   | 0.096044   |   0.0 |  0.95
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.36075    | 0.36075    | 0.36075    |   0.0 |  3.59
Other   |            | 0.06265    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4003.00 ave        4003 max        4003 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:      126420.0 ave      126420 max      126420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126420
Ave neighs/atom = 63.210000
Neighbor list builds = 0
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 = 292.952508258765, Press = 1.61486159565507
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17645.092   -17645.092   -17721.399   -17721.399    295.31428    295.31428     31825.89     31825.89   -1156.7348   -1156.7348 
   41000   -17648.855   -17648.855   -17724.406   -17724.406    292.39017    292.39017    31814.099    31814.099   -480.03444   -480.03444 
Loop time of 10.0233 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.620 ns/day, 2.784 hours/ns, 99.767 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    | 9.5075     | 9.5075     | 9.5075     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095915   | 0.095915   | 0.095915   |   0.0 |  0.96
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.35781    | 0.35781    | 0.35781    |   0.0 |  3.57
Other   |            | 0.06188    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4018.00 ave        4018 max        4018 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:      126186.0 ave      126186 max      126186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126186
Ave neighs/atom = 63.093000
Neighbor list builds = 0
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 = 292.941961924339, Press = 0.148450166172567
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17648.855   -17648.855   -17724.406   -17724.406    292.39017    292.39017    31814.099    31814.099   -480.03444   -480.03444 
   42000   -17645.909   -17645.909   -17721.706   -17721.706    293.34445    293.34445    31816.788    31816.788   -175.71427   -175.71427 
Loop time of 10.1327 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.527 ns/day, 2.815 hours/ns, 98.691 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    | 9.6082     | 9.6082     | 9.6082     |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096947   | 0.096947   | 0.096947   |   0.0 |  0.96
Output  | 0.00019806 | 0.00019806 | 0.00019806 |   0.0 |  0.00
Modify  | 0.36432    | 0.36432    | 0.36432    |   0.0 |  3.60
Other   |            | 0.06302    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3999.00 ave        3999 max        3999 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:      126274.0 ave      126274 max      126274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126274
Ave neighs/atom = 63.137000
Neighbor list builds = 0
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 = 292.909647650028, Press = 1.19801011188003
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17645.909   -17645.909   -17721.706   -17721.706    293.34445    293.34445    31816.788    31816.788   -175.71427   -175.71427 
   43000   -17645.808   -17645.808   -17721.371   -17721.371     292.4357     292.4357    31839.438    31839.438   -1926.2382   -1926.2382 
Loop time of 10.4087 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.301 ns/day, 2.891 hours/ns, 96.074 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    | 9.8725     | 9.8725     | 9.8725     |   0.0 | 94.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098944   | 0.098944   | 0.098944   |   0.0 |  0.95
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.37407    | 0.37407    | 0.37407    |   0.0 |  3.59
Other   |            | 0.06302    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4035.00 ave        4035 max        4035 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:      126150.0 ave      126150 max      126150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126150
Ave neighs/atom = 63.075000
Neighbor list builds = 0
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 = 292.843331162503, Press = 0.3194199534851
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17645.808   -17645.808   -17721.371   -17721.371     292.4357     292.4357    31839.438    31839.438   -1926.2382   -1926.2382 
   44000   -17648.491   -17648.491   -17724.036   -17724.036      292.369      292.369    31795.142    31795.142     1528.825     1528.825 
Loop time of 10.2659 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.416 ns/day, 2.852 hours/ns, 97.410 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    | 9.7343     | 9.7343     | 9.7343     |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097646   | 0.097646   | 0.097646   |   0.0 |  0.95
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.37113    | 0.37113    | 0.37113    |   0.0 |  3.62
Other   |            | 0.06265    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3990.00 ave        3990 max        3990 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:      126172.0 ave      126172 max      126172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126172
Ave neighs/atom = 63.086000
Neighbor list builds = 0
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 = 292.842091605069, Press = 0.6257050430727
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17648.491   -17648.491   -17724.036   -17724.036      292.369      292.369    31795.142    31795.142     1528.825     1528.825 
   45000   -17646.318   -17646.318   -17722.418   -17722.418    294.51295    294.51295    31788.091    31788.091    2338.7408    2338.7408 
Loop time of 10.5696 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.174 ns/day, 2.936 hours/ns, 94.611 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    | 10.022     | 10.022     | 10.022     |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10099    | 0.10099    | 0.10099    |   0.0 |  0.96
Output  | 0.00015255 | 0.00015255 | 0.00015255 |   0.0 |  0.00
Modify  | 0.38262    | 0.38262    | 0.38262    |   0.0 |  3.62
Other   |            | 0.0637     |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 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:      126368.0 ave      126368 max      126368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126368
Ave neighs/atom = 63.184000
Neighbor list builds = 0
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 = 292.903397684219, Press = 2.32155842183686
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17646.318   -17646.318   -17722.418   -17722.418    294.51295    294.51295    31788.091    31788.091    2338.7408    2338.7408 
   46000   -17646.758   -17646.758   -17722.364   -17722.364    292.60093    292.60093    31840.522    31840.522   -2025.3246   -2025.3246 
Loop time of 9.94249 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.690 ns/day, 2.762 hours/ns, 100.578 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    | 9.4292     | 9.4292     | 9.4292     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094889   | 0.094889   | 0.094889   |   0.0 |  0.95
Output  | 0.0001966  | 0.0001966  | 0.0001966  |   0.0 |  0.00
Modify  | 0.35599    | 0.35599    | 0.35599    |   0.0 |  3.58
Other   |            | 0.0622     |            |       |  0.63

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3989.00 ave        3989 max        3989 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:      126344.0 ave      126344 max      126344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126344
Ave neighs/atom = 63.172000
Neighbor list builds = 0
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 = 292.915672121359, Press = 1.75547510361759
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17646.758   -17646.758   -17722.364   -17722.364    292.60093    292.60093    31840.522    31840.522   -2025.3246   -2025.3246 
   47000   -17646.858   -17646.858   -17720.169   -17720.169    283.71988    283.71988    31828.076    31828.076   -903.64091   -903.64091 
Loop time of 9.95817 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.676 ns/day, 2.766 hours/ns, 100.420 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    | 9.446      | 9.446      | 9.446      |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094855   | 0.094855   | 0.094855   |   0.0 |  0.95
Output  | 0.00015584 | 0.00015584 | 0.00015584 |   0.0 |  0.00
Modify  | 0.35529    | 0.35529    | 0.35529    |   0.0 |  3.57
Other   |            | 0.06183    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4009.00 ave        4009 max        4009 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:      126216.0 ave      126216 max      126216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126216
Ave neighs/atom = 63.108000
Neighbor list builds = 0
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 = 292.933350183266, Press = 0.251909853607745
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17646.858   -17646.858   -17720.169   -17720.169    283.71988    283.71988    31828.076    31828.076   -903.64091   -903.64091 
   48000    -17644.67    -17644.67    -17721.91    -17721.91    298.92447    298.92447     31810.75     31810.75    686.76084    686.76084 
Loop time of 10.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.576 ns/day, 2.799 hours/ns, 99.255 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    | 9.5595     | 9.5595     | 9.5595     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095871   | 0.095871   | 0.095871   |   0.0 |  0.95
Output  | 0.0002046  | 0.0002046  | 0.0002046  |   0.0 |  0.00
Modify  | 0.35755    | 0.35755    | 0.35755    |   0.0 |  3.55
Other   |            | 0.06191    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 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:      126114.0 ave      126114 max      126114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126114
Ave neighs/atom = 63.057000
Neighbor list builds = 0
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 = 292.938251924636, Press = 1.54700530878462
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -17644.67    -17644.67    -17721.91    -17721.91    298.92447    298.92447     31810.75     31810.75    686.76084    686.76084 
   49000   -17646.824   -17646.824   -17720.797   -17720.797    286.28242    286.28242    31856.318    31856.318   -3134.9796   -3134.9796 
Loop time of 10.2683 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.414 ns/day, 2.852 hours/ns, 97.387 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    | 9.7428     | 9.7428     | 9.7428     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096695   | 0.096695   | 0.096695   |   0.0 |  0.94
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.366      | 0.366      | 0.366      |   0.0 |  3.56
Other   |            | 0.06263    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4014.00 ave        4014 max        4014 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:      126318.0 ave      126318 max      126318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126318
Ave neighs/atom = 63.159000
Neighbor list builds = 0
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 = 292.903515106447, Press = 1.30867398736318
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17646.824   -17646.824   -17720.797   -17720.797    286.28242    286.28242    31856.318    31856.318   -3134.9796   -3134.9796 
   50000   -17645.023   -17645.023   -17720.076   -17720.076    290.46113    290.46113    31839.057    31839.057   -1962.7876   -1962.7876 
Loop time of 10.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.599 ns/day, 2.791 hours/ns, 99.522 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    | 9.5279     | 9.5279     | 9.5279     |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096228   | 0.096228   | 0.096228   |   0.0 |  0.96
Output  | 0.00015644 | 0.00015644 | 0.00015644 |   0.0 |  0.00
Modify  | 0.36161    | 0.36161    | 0.36161    |   0.0 |  3.60
Other   |            | 0.06214    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 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:      126072.0 ave      126072 max      126072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126072
Ave neighs/atom = 63.036000
Neighbor list builds = 0
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 = 292.863526235319, Press = 0.175136327689595
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17645.023   -17645.023   -17720.076   -17720.076    290.46113    290.46113    31839.057    31839.057   -1962.7876   -1962.7876 
   51000   -17649.174   -17649.174     -17724.9     -17724.9    293.06709    293.06709    31776.344    31776.344     3462.292     3462.292 
Loop time of 10.4696 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.252 ns/day, 2.908 hours/ns, 95.514 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    | 9.9249     | 9.9249     | 9.9249     |   0.0 | 94.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099344   | 0.099344   | 0.099344   |   0.0 |  0.95
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.38137    | 0.38137    | 0.38137    |   0.0 |  3.64
Other   |            | 0.0639     |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3991.00 ave        3991 max        3991 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:      126110.0 ave      126110 max      126110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126110
Ave neighs/atom = 63.055000
Neighbor list builds = 0
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 = 292.852908586622, Press = 0.83167811524864
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17649.174   -17649.174     -17724.9     -17724.9    293.06709    293.06709    31776.344    31776.344     3462.292     3462.292 
   52000   -17646.355   -17646.355     -17723.9     -17723.9    300.10709    300.10709    31801.391    31801.391    1437.2449    1437.2449 
Loop time of 10.6398 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.120 ns/day, 2.956 hours/ns, 93.987 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    | 10.088     | 10.088     | 10.088     |   0.0 | 94.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10169    | 0.10169    | 0.10169    |   0.0 |  0.96
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.38604    | 0.38604    | 0.38604    |   0.0 |  3.63
Other   |            | 0.06404    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4049.00 ave        4049 max        4049 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:      126474.0 ave      126474 max      126474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126474
Ave neighs/atom = 63.237000
Neighbor list builds = 0
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 = 292.85464718707, Press = 1.89660832127894
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17646.355   -17646.355     -17723.9     -17723.9    300.10709    300.10709    31801.391    31801.391    1437.2449    1437.2449 
   53000    -17646.71    -17646.71   -17722.141   -17722.141    291.92282    291.92282    31846.554    31846.554   -3260.2558   -3260.2558 
Loop time of 9.97324 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.663 ns/day, 2.770 hours/ns, 100.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    | 9.4605     | 9.4605     | 9.4605     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094504   | 0.094504   | 0.094504   |   0.0 |  0.95
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.35621    | 0.35621    | 0.35621    |   0.0 |  3.57
Other   |            | 0.06184    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4012.00 ave        4012 max        4012 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:      126324.0 ave      126324 max      126324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126324
Ave neighs/atom = 63.162000
Neighbor list builds = 0
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 = 292.886426697412, Press = 0.168881642651598
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -17646.71    -17646.71   -17722.141   -17722.141    291.92282    291.92282    31846.554    31846.554   -3260.2558   -3260.2558 
   54000   -17646.068   -17646.068   -17721.824   -17721.824    293.18379    293.18379    31798.185    31798.185    1719.3582    1719.3582 
Loop time of 9.96251 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.673 ns/day, 2.767 hours/ns, 100.376 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    | 9.4501     | 9.4501     | 9.4501     |   0.0 | 94.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094662   | 0.094662   | 0.094662   |   0.0 |  0.95
Output  | 0.00020223 | 0.00020223 | 0.00020223 |   0.0 |  0.00
Modify  | 0.35531    | 0.35531    | 0.35531    |   0.0 |  3.57
Other   |            | 0.06224    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4007.00 ave        4007 max        4007 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:      126122.0 ave      126122 max      126122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126122
Ave neighs/atom = 63.061000
Neighbor list builds = 0
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 = 292.90105938782, Press = 0.303384921841663
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17646.068   -17646.068   -17721.824   -17721.824    293.18379    293.18379    31798.185    31798.185    1719.3582    1719.3582 
   55000   -17646.919   -17646.919   -17723.515   -17723.515    296.43386    296.43386    31807.204    31807.204    468.07935    468.07935 
Loop time of 10.5328 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.203 ns/day, 2.926 hours/ns, 94.941 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    | 9.9966     | 9.9966     | 9.9966     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099893   | 0.099893   | 0.099893   |   0.0 |  0.95
Output  | 0.00019934 | 0.00019934 | 0.00019934 |   0.0 |  0.00
Modify  | 0.37376    | 0.37376    | 0.37376    |   0.0 |  3.55
Other   |            | 0.06241    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4035.00 ave        4035 max        4035 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:      126266.0 ave      126266 max      126266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126266
Ave neighs/atom = 63.133000
Neighbor list builds = 0
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 = 292.963489778905, Press = 0.419905246139973
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17646.919   -17646.919   -17723.515   -17723.515    296.43386    296.43386    31807.204    31807.204    468.07935    468.07935 
   56000   -17645.389   -17645.389   -17721.004   -17721.004      292.638      292.638     31816.29     31816.29    300.72903    300.72903 
Loop time of 10.1121 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.544 ns/day, 2.809 hours/ns, 98.891 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    | 9.5905     | 9.5905     | 9.5905     |   0.0 | 94.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097335   | 0.097335   | 0.097335   |   0.0 |  0.96
Output  | 0.00015197 | 0.00015197 | 0.00015197 |   0.0 |  0.00
Modify  | 0.36167    | 0.36167    | 0.36167    |   0.0 |  3.58
Other   |            | 0.06242    |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4064.00 ave        4064 max        4064 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:      126306.0 ave      126306 max      126306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126306
Ave neighs/atom = 63.153000
Neighbor list builds = 0
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 = 292.965461765801, Press = 1.88153055250698
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17645.389   -17645.389   -17721.004   -17721.004      292.638      292.638     31816.29     31816.29    300.72903    300.72903 
   57000   -17647.965   -17647.965   -17723.091   -17723.091     290.7443     290.7443    31834.412    31834.412   -1570.1585   -1570.1585 
Loop time of 10.1261 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.532 ns/day, 2.813 hours/ns, 98.755 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    | 9.602      | 9.602      | 9.602      |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097829   | 0.097829   | 0.097829   |   0.0 |  0.97
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.36332    | 0.36332    | 0.36332    |   0.0 |  3.59
Other   |            | 0.0628     |            |       |  0.62

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4041.00 ave        4041 max        4041 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:      126176.0 ave      126176 max      126176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126176
Ave neighs/atom = 63.088000
Neighbor list builds = 0
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 = 292.981055577434, Press = 0.662122160419181
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.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17647.965   -17647.965   -17723.091   -17723.091     290.7443     290.7443    31834.412    31834.412   -1570.1585   -1570.1585 
   58000   -17642.461   -17642.461   -17719.742   -17719.742    299.08582    299.08582    31832.041    31832.041   -1097.1376   -1097.1376 
Loop time of 10.4742 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.249 ns/day, 2.910 hours/ns, 95.472 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    | 9.9313     | 9.9313     | 9.9313     |   0.0 | 94.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099912   | 0.099912   | 0.099912   |   0.0 |  0.95
Output  | 0.00015188 | 0.00015188 | 0.00015188 |   0.0 |  0.00
Modify  | 0.37931    | 0.37931    | 0.37931    |   0.0 |  3.62
Other   |            | 0.06356    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4036.00 ave        4036 max        4036 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:      126158.0 ave      126158 max      126158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126158
Ave neighs/atom = 63.079000
Neighbor list builds = 0
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
31814.8547839446

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0