# 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.143073618412018*${_u_distance}
variable latticeconst_converted equal 3.143073618412018*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14307361841202
Lattice spacing in x,y,z = 3.1430736 3.1430736 3.1430736
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.430736 31.430736 31.430736)
  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.430736 31.430736 31.430736)
  create_atoms CPU = 0.002 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_SetyawanGaoKurtz_2018_ReW__MO_680820064987_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 31050.1469652883    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 31050.1469652883/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 31050.1469652883/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 31050.1469652883/(1*1*${_u_distance})
variable      V0_metal equal 31050.1469652883/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 31050.1469652883*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31050.1469652883 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_680820064987_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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17735.868   -17735.868    -17801.28    -17801.28       253.15       253.15    31050.147    31050.147    2250.1203    2250.1203 
    1000    -17684.09    -17684.09   -17748.159   -17748.159    247.95381    247.95381    31243.577    31243.577    2418.6708    2418.6708 
Loop time of 25.4335 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.397 ns/day, 7.065 hours/ns, 39.318 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    | 24.904     | 24.904     | 24.904     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10198    | 0.10198    | 0.10198    |   0.0 |  0.40
Output  | 0.00019764 | 0.00019764 | 0.00019764 |   0.0 |  0.00
Modify  | 0.36479    | 0.36479    | 0.36479    |   0.0 |  1.43
Other   |            | 0.06275    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -17684.09    -17684.09   -17748.159   -17748.159    247.95381    247.95381    31243.577    31243.577    2418.6708    2418.6708 
    2000   -17677.198   -17677.198   -17744.646   -17744.646    261.03408    261.03408     31271.51     31271.51    935.21843    935.21843 
Loop time of 25.7364 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.357 ns/day, 7.149 hours/ns, 38.855 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    | 25.218     | 25.218     | 25.218     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099708   | 0.099708   | 0.099708   |   0.0 |  0.39
Output  | 0.00018029 | 0.00018029 | 0.00018029 |   0.0 |  0.00
Modify  | 0.35747    | 0.35747    | 0.35747    |   0.0 |  1.39
Other   |            | 0.06155    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17677.198   -17677.198   -17744.646   -17744.646    261.03408    261.03408     31271.51     31271.51    935.21843    935.21843 
    3000   -17681.153   -17681.153   -17747.274   -17747.274     255.8971     255.8971     31284.74     31284.74   -2371.9674   -2371.9674 
Loop time of 25.0387 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.451 ns/day, 6.955 hours/ns, 39.938 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    | 24.532     | 24.532     | 24.532     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097454   | 0.097454   | 0.097454   |   0.0 |  0.39
Output  | 0.00018581 | 0.00018581 | 0.00018581 |   0.0 |  0.00
Modify  | 0.34757    | 0.34757    | 0.34757    |   0.0 |  1.39
Other   |            | 0.06106    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17681.153   -17681.153   -17747.274   -17747.274     255.8971     255.8971     31284.74     31284.74   -2371.9674   -2371.9674 
    4000   -17681.312   -17681.312   -17744.942   -17744.942    246.25582    246.25582    31255.591    31255.591    2535.4572    2535.4572 
Loop time of 25.2515 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.422 ns/day, 7.014 hours/ns, 39.602 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    | 24.743     | 24.743     | 24.743     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097683   | 0.097683   | 0.097683   |   0.0 |  0.39
Output  | 0.00019289 | 0.00019289 | 0.00019289 |   0.0 |  0.00
Modify  | 0.35016    | 0.35016    | 0.35016    |   0.0 |  1.39
Other   |            | 0.0609     |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17681.312   -17681.312   -17744.942   -17744.942    246.25582    246.25582    31255.591    31255.591    2535.4572    2535.4572 
    5000   -17678.603   -17678.603   -17745.042   -17745.042    257.12931    257.12931    31257.251    31257.251    1951.1381    1951.1381 
Loop time of 25.1279 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.796 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    | 24.619     | 24.619     | 24.619     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097849   | 0.097849   | 0.097849   |   0.0 |  0.39
Output  | 0.00020119 | 0.00020119 | 0.00020119 |   0.0 |  0.00
Modify  | 0.34976    | 0.34976    | 0.34976    |   0.0 |  1.39
Other   |            | 0.06067    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 256.36653504366, Press = 288.333032027363
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17678.603   -17678.603   -17745.042   -17745.042    257.12931    257.12931    31257.251    31257.251    1951.1381    1951.1381 
    6000   -17680.797   -17680.797   -17744.446   -17744.446    246.32681    246.32681    31248.768    31248.768    3641.5043    3641.5043 
Loop time of 25.1808 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.431 ns/day, 6.995 hours/ns, 39.713 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    | 24.655     | 24.655     | 24.655     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098547   | 0.098547   | 0.098547   |   0.0 |  0.39
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.36565    | 0.36565    | 0.36565    |   0.0 |  1.45
Other   |            | 0.06142    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 251.521677296712, Press = 70.5172973789976
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17680.797   -17680.797   -17744.446   -17744.446    246.32681    246.32681    31248.768    31248.768    3641.5043    3641.5043 
    7000   -17680.603   -17680.603   -17746.457   -17746.457    254.86259    254.86259    31273.043    31273.043   -40.890808   -40.890808 
Loop time of 25.2979 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.415 ns/day, 7.027 hours/ns, 39.529 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    | 24.768     | 24.768     | 24.768     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099326   | 0.099326   | 0.099326   |   0.0 |  0.39
Output  | 0.00019357 | 0.00019357 | 0.00019357 |   0.0 |  0.00
Modify  | 0.3697     | 0.3697     | 0.3697     |   0.0 |  1.46
Other   |            | 0.06078    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 252.190842209055, Press = 29.8305819964438
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17680.603   -17680.603   -17746.457   -17746.457    254.86259    254.86259    31273.043    31273.043   -40.890808   -40.890808 
    8000    -17681.77    -17681.77   -17746.834   -17746.834    251.80765    251.80765    31270.207    31270.207   -1475.6077   -1475.6077 
Loop time of 25.2869 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.417 ns/day, 7.024 hours/ns, 39.546 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    | 24.758     | 24.758     | 24.758     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098752   | 0.098752   | 0.098752   |   0.0 |  0.39
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.36842    | 0.36842    | 0.36842    |   0.0 |  1.46
Other   |            | 0.06136    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 252.331799366715, Press = 22.0176013963304
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -17681.77    -17681.77   -17746.834   -17746.834    251.80765    251.80765    31270.207    31270.207   -1475.6077   -1475.6077 
    9000   -17680.534   -17680.534   -17746.084   -17746.084     253.6849     253.6849    31276.965    31276.965   -1394.7973   -1394.7973 
Loop time of 25.5622 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.380 ns/day, 7.101 hours/ns, 39.120 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    | 25.032     | 25.032     | 25.032     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099471   | 0.099471   | 0.099471   |   0.0 |  0.39
Output  | 0.00025177 | 0.00025177 | 0.00025177 |   0.0 |  0.00
Modify  | 0.36913    | 0.36913    | 0.36913    |   0.0 |  1.44
Other   |            | 0.06125    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 252.897944035707, Press = 19.0309174245515
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17680.534   -17680.534   -17746.084   -17746.084     253.6849     253.6849    31276.965    31276.965   -1394.7973   -1394.7973 
   10000   -17676.172   -17676.172   -17743.502   -17743.502    260.57335    260.57335    31249.506    31249.506     3377.156     3377.156 
Loop time of 25.7032 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.361 ns/day, 7.140 hours/ns, 38.906 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    | 25.169     | 25.169     | 25.169     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099974   | 0.099974   | 0.099974   |   0.0 |  0.39
Output  | 0.00019904 | 0.00019904 | 0.00019904 |   0.0 |  0.00
Modify  | 0.37242    | 0.37242    | 0.37242    |   0.0 |  1.45
Other   |            | 0.06127    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.305551060896, Press = 11.470982439961
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17676.172   -17676.172   -17743.502   -17743.502    260.57335    260.57335    31249.506    31249.506     3377.156     3377.156 
   11000   -17679.216   -17679.216     -17745.2     -17745.2     255.3645     255.3645    31303.737    31303.737   -4161.1882   -4161.1882 
Loop time of 25.7628 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.354 ns/day, 7.156 hours/ns, 38.816 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    | 25.221     | 25.221     | 25.221     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10036    | 0.10036    | 0.10036    |   0.0 |  0.39
Output  | 0.0001575  | 0.0001575  | 0.0001575  |   0.0 |  0.00
Modify  | 0.37965    | 0.37965    | 0.37965    |   0.0 |  1.47
Other   |            | 0.06141    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.395880579848, Press = -1.18676460781233
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17679.216   -17679.216     -17745.2     -17745.2     255.3645     255.3645    31303.737    31303.737   -4161.1882   -4161.1882 
   12000   -17684.008   -17684.008   -17747.805   -17747.805    246.90143    246.90143    31253.793    31253.793    1036.9906    1036.9906 
Loop time of 26.1643 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.302 ns/day, 7.268 hours/ns, 38.220 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    | 25.617     | 25.617     | 25.617     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1022     | 0.1022     | 0.1022     |   0.0 |  0.39
Output  | 0.00015378 | 0.00015378 | 0.00015378 |   0.0 |  0.00
Modify  | 0.38345    | 0.38345    | 0.38345    |   0.0 |  1.47
Other   |            | 0.06189    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.249802919763, Press = 2.40807186537129
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17684.008   -17684.008   -17747.805   -17747.805    246.90143    246.90143    31253.793    31253.793    1036.9906    1036.9906 
   13000    -17678.77    -17678.77   -17745.171   -17745.171    256.97964    256.97964    31221.387    31221.387     6378.471     6378.471 
Loop time of 25.1439 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.436 ns/day, 6.984 hours/ns, 39.771 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    | 24.62      | 24.62      | 24.62      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098489   | 0.098489   | 0.098489   |   0.0 |  0.39
Output  | 0.00015911 | 0.00015911 | 0.00015911 |   0.0 |  0.00
Modify  | 0.36458    | 0.36458    | 0.36458    |   0.0 |  1.45
Other   |            | 0.06072    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.12160070854, Press = 6.46781926670914
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -17678.77    -17678.77   -17745.171   -17745.171    256.97964    256.97964    31221.387    31221.387     6378.471     6378.471 
   14000   -17681.903   -17681.903   -17746.125   -17746.125    248.54554    248.54554    31271.967    31271.967   -517.70529   -517.70529 
Loop time of 25.1525 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.987 hours/ns, 39.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.625     | 24.625     | 24.625     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098952   | 0.098952   | 0.098952   |   0.0 |  0.39
Output  | 0.000188   | 0.000188   | 0.000188   |   0.0 |  0.00
Modify  | 0.36706    | 0.36706    | 0.36706    |   0.0 |  1.46
Other   |            | 0.06144    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.173334720688, Press = 6.19307982749158
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17681.903   -17681.903   -17746.125   -17746.125    248.54554    248.54554    31271.967    31271.967   -517.70529   -517.70529 
   15000   -17679.648   -17679.648    -17745.61    -17745.61    255.28252    255.28252    31271.482    31271.482   -287.06517   -287.06517 
Loop time of 25.6681 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.366 ns/day, 7.130 hours/ns, 38.959 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    | 25.126     | 25.126     | 25.126     |   0.0 | 97.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10141    | 0.10141    | 0.10141    |   0.0 |  0.40
Output  | 0.00020002 | 0.00020002 | 0.00020002 |   0.0 |  0.00
Modify  | 0.37807    | 0.37807    | 0.37807    |   0.0 |  1.47
Other   |            | 0.06226    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.277201891048, Press = 5.56756104334823
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17679.648   -17679.648    -17745.61    -17745.61    255.28252    255.28252    31271.482    31271.482   -287.06517   -287.06517 
   16000   -17680.973   -17680.973   -17746.485   -17746.485    253.53841    253.53841    31250.412    31250.412    2290.9641    2290.9641 
Loop time of 25.1988 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.429 ns/day, 7.000 hours/ns, 39.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    | 24.673     | 24.673     | 24.673     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098433   | 0.098433   | 0.098433   |   0.0 |  0.39
Output  | 0.0001503  | 0.0001503  | 0.0001503  |   0.0 |  0.00
Modify  | 0.36525    | 0.36525    | 0.36525    |   0.0 |  1.45
Other   |            | 0.06145    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.369273648878, Press = 4.66546792904636
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17680.973   -17680.973   -17746.485   -17746.485    253.53841    253.53841    31250.412    31250.412    2290.9641    2290.9641 
   17000   -17682.177   -17682.177   -17746.372   -17746.372    248.44121    248.44121    31280.092    31280.092   -1638.1519   -1638.1519 
Loop time of 24.9418 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.464 ns/day, 6.928 hours/ns, 40.093 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    | 24.423     | 24.423     | 24.423     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097757   | 0.097757   | 0.097757   |   0.0 |  0.39
Output  | 0.00015402 | 0.00015402 | 0.00015402 |   0.0 |  0.00
Modify  | 0.36061    | 0.36061    | 0.36061    |   0.0 |  1.45
Other   |            | 0.06055    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.477377199169, Press = -0.482508497771104
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17682.177   -17682.177   -17746.372   -17746.372    248.44121    248.44121    31280.092    31280.092   -1638.1519   -1638.1519 
   18000   -17678.614   -17678.614    -17745.82    -17745.82    260.09401    260.09401    31269.211    31269.211    198.22261    198.22261 
Loop time of 25.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.403 ns/day, 7.052 hours/ns, 39.390 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    | 24.857     | 24.857     | 24.857     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099468   | 0.099468   | 0.099468   |   0.0 |  0.39
Output  | 0.00015888 | 0.00015888 | 0.00015888 |   0.0 |  0.00
Modify  | 0.36975    | 0.36975    | 0.36975    |   0.0 |  1.46
Other   |            | 0.06109    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.560412382947, Press = 5.86518283162172
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17678.614   -17678.614    -17745.82    -17745.82    260.09401    260.09401    31269.211    31269.211    198.22261    198.22261 
   19000   -17680.678   -17680.678   -17745.647   -17745.647     251.4365     251.4365    31258.185    31258.185    1471.3273    1471.3273 
Loop time of 25.2083 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.002 hours/ns, 39.669 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    | 24.681     | 24.681     | 24.681     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099419   | 0.099419   | 0.099419   |   0.0 |  0.39
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.36673    | 0.36673    | 0.36673    |   0.0 |  1.45
Other   |            | 0.06058    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.619946022047, Press = 2.65605819345343
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17680.678   -17680.678   -17745.647   -17745.647     251.4365     251.4365    31258.185    31258.185    1471.3273    1471.3273 
   20000   -17682.086   -17682.086   -17745.972   -17745.972    247.24486    247.24486    31274.635    31274.635   -669.62456   -669.62456 
Loop time of 25.7272 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.358 ns/day, 7.146 hours/ns, 38.869 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.19      | 25.19      | 25.19      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09996    | 0.09996    | 0.09996    |   0.0 |  0.39
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.37559    | 0.37559    | 0.37559    |   0.0 |  1.46
Other   |            | 0.06149    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.581984725626, Press = 4.29372511005197
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17682.086   -17682.086   -17745.972   -17745.972    247.24486    247.24486    31274.635    31274.635   -669.62456   -669.62456 
   21000   -17680.302   -17680.302   -17745.144   -17745.144    250.94468    250.94468    31281.029    31281.029   -707.15697   -707.15697 
Loop time of 25.3169 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.413 ns/day, 7.032 hours/ns, 39.499 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    | 24.786     | 24.786     | 24.786     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099181   | 0.099181   | 0.099181   |   0.0 |  0.39
Output  | 0.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.36994    | 0.36994    | 0.36994    |   0.0 |  1.46
Other   |            | 0.0618     |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.536521036265, Press = 2.01793947988111
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17680.302   -17680.302   -17745.144   -17745.144    250.94468    250.94468    31281.029    31281.029   -707.15697   -707.15697 
   22000   -17679.787   -17679.787   -17745.987   -17745.987    256.19924    256.19924    31280.043    31280.043   -1506.4908   -1506.4908 
Loop time of 25.1833 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.431 ns/day, 6.995 hours/ns, 39.709 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    | 24.655     | 24.655     | 24.655     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098268   | 0.098268   | 0.098268   |   0.0 |  0.39
Output  | 0.0001521  | 0.0001521  | 0.0001521  |   0.0 |  0.00
Modify  | 0.3694     | 0.3694     | 0.3694     |   0.0 |  1.47
Other   |            | 0.06061    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.534259969392, Press = 2.34300900706143
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17679.787   -17679.787   -17745.987   -17745.987    256.19924    256.19924    31280.043    31280.043   -1506.4908   -1506.4908 
   23000    -17679.63    -17679.63     -17745.1     -17745.1    253.37552    253.37552    31275.286    31275.286   -302.67729   -302.67729 
Loop time of 25.1417 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.437 ns/day, 6.984 hours/ns, 39.775 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    | 24.615     | 24.615     | 24.615     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098415   | 0.098415   | 0.098415   |   0.0 |  0.39
Output  | 0.00015292 | 0.00015292 | 0.00015292 |   0.0 |  0.00
Modify  | 0.36696    | 0.36696    | 0.36696    |   0.0 |  1.46
Other   |            | 0.06101    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.464009213959, Press = 1.48809122077823
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -17679.63    -17679.63     -17745.1     -17745.1    253.37552    253.37552    31275.286    31275.286   -302.67729   -302.67729 
   24000   -17682.989   -17682.989   -17747.623   -17747.623    250.13866    250.13866    31243.857    31243.857    2398.3653    2398.3653 
Loop time of 25.6662 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.366 ns/day, 7.129 hours/ns, 38.962 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    | 25.128     | 25.128     | 25.128     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099696   | 0.099696   | 0.099696   |   0.0 |  0.39
Output  | 0.00019707 | 0.00019707 | 0.00019707 |   0.0 |  0.00
Modify  | 0.37675    | 0.37675    | 0.37675    |   0.0 |  1.47
Other   |            | 0.06169    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.342055832092, Press = 4.0453317823433
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17682.989   -17682.989   -17747.623   -17747.623    250.13866    250.13866    31243.857    31243.857    2398.3653    2398.3653 
   25000   -17678.133   -17678.133   -17744.605   -17744.605    257.25209    257.25209    31289.135    31289.135   -1936.0026   -1936.0026 
Loop time of 25.3332 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.411 ns/day, 7.037 hours/ns, 39.474 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    | 24.806     | 24.806     | 24.806     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098722   | 0.098722   | 0.098722   |   0.0 |  0.39
Output  | 0.00019403 | 0.00019403 | 0.00019403 |   0.0 |  0.00
Modify  | 0.36772    | 0.36772    | 0.36772    |   0.0 |  1.45
Other   |            | 0.06043    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.316713852346, Press = 2.77242058354267
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17678.133   -17678.133   -17744.605   -17744.605    257.25209    257.25209    31289.135    31289.135   -1936.0026   -1936.0026 
   26000   -17680.728   -17680.728   -17745.245   -17745.245    249.68755    249.68755     31266.53     31266.53    135.54157    135.54157 
Loop time of 25.9866 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.325 ns/day, 7.219 hours/ns, 38.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    | 25.444     | 25.444     | 25.444     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1016     | 0.1016     | 0.1016     |   0.0 |  0.39
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.3792     | 0.3792     | 0.3792     |   0.0 |  1.46
Other   |            | 0.06182    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.341851672368, Press = 2.39437425056681
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17680.728   -17680.728   -17745.245   -17745.245    249.68755    249.68755     31266.53     31266.53    135.54157    135.54157 
   27000   -17680.501   -17680.501   -17744.295   -17744.295    246.88666    246.88666    31291.177    31291.177   -2340.4995   -2340.4995 
Loop time of 26.2205 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.295 ns/day, 7.283 hours/ns, 38.138 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    | 25.675     | 25.675     | 25.675     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.38
Output  | 0.00015176 | 0.00015176 | 0.00015176 |   0.0 |  0.00
Modify  | 0.3824     | 0.3824     | 0.3824     |   0.0 |  1.46
Other   |            | 0.06216    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.44988068438, Press = 1.44117544189793
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17680.501   -17680.501   -17744.295   -17744.295    246.88666    246.88666    31291.177    31291.177   -2340.4995   -2340.4995 
   28000   -17679.061   -17679.061   -17744.148   -17744.148    251.89615    251.89615     31314.78     31314.78   -5096.6861   -5096.6861 
Loop time of 25.0152 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.454 ns/day, 6.949 hours/ns, 39.976 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    | 24.492     | 24.492     | 24.492     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097782   | 0.097782   | 0.097782   |   0.0 |  0.39
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.3644     | 0.3644     | 0.3644     |   0.0 |  1.46
Other   |            | 0.0612     |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.356913329368, Press = 3.47153544532657
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17679.061   -17679.061   -17744.148   -17744.148    251.89615    251.89615     31314.78     31314.78   -5096.6861   -5096.6861 
   29000   -17679.654   -17679.654    -17745.96    -17745.96    256.61194    256.61194    31232.671    31232.671    4776.3595    4776.3595 
Loop time of 25.8297 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.345 ns/day, 7.175 hours/ns, 38.715 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    | 25.289     | 25.289     | 25.289     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.39
Output  | 0.0002036  | 0.0002036  | 0.0002036  |   0.0 |  0.00
Modify  | 0.37884    | 0.37884    | 0.37884    |   0.0 |  1.47
Other   |            | 0.06182    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.30171670354, Press = 2.42838513904852
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17679.654   -17679.654    -17745.96    -17745.96    256.61194    256.61194    31232.671    31232.671    4776.3595    4776.3595 
   30000   -17684.217   -17684.217   -17747.707   -17747.707    245.71608    245.71608    31268.808    31268.808   -1079.0903   -1079.0903 
Loop time of 25.0512 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.449 ns/day, 6.959 hours/ns, 39.918 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    | 24.526     | 24.526     | 24.526     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09795    | 0.09795    | 0.09795    |   0.0 |  0.39
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.3656     | 0.3656     | 0.3656     |   0.0 |  1.46
Other   |            | 0.06146    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.274201291368, Press = 2.89130716779526
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17684.217   -17684.217   -17747.707   -17747.707    245.71608    245.71608    31268.808    31268.808   -1079.0903   -1079.0903 
   31000   -17679.773   -17679.773   -17745.884   -17745.884    255.85848    255.85848    31279.233    31279.233   -863.83167   -863.83167 
Loop time of 25.4701 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.392 ns/day, 7.075 hours/ns, 39.262 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    | 24.937     | 24.937     | 24.937     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098751   | 0.098751   | 0.098751   |   0.0 |  0.39
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.37285    | 0.37285    | 0.37285    |   0.0 |  1.46
Other   |            | 0.06136    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.212545039648, Press = 2.63896043006799
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17679.773   -17679.773   -17745.884   -17745.884    255.85848    255.85848    31279.233    31279.233   -863.83167   -863.83167 
   32000   -17677.256   -17677.256   -17743.598   -17743.598     256.7505     256.7505    31283.351    31283.351   -1000.6394   -1000.6394 
Loop time of 25.6844 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.364 ns/day, 7.135 hours/ns, 38.934 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    | 25.144     | 25.144     | 25.144     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10016    | 0.10016    | 0.10016    |   0.0 |  0.39
Output  | 0.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.37811    | 0.37811    | 0.37811    |   0.0 |  1.47
Other   |            | 0.06188    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.210507342003, Press = 0.994124071328555
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17677.256   -17677.256   -17743.598   -17743.598     256.7505     256.7505    31283.351    31283.351   -1000.6394   -1000.6394 
   33000   -17680.179   -17680.179   -17744.322   -17744.322    248.24343    248.24343    31310.349    31310.349   -4943.5963   -4943.5963 
Loop time of 25.1633 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.434 ns/day, 6.990 hours/ns, 39.740 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    | 24.637     | 24.637     | 24.637     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098841   | 0.098841   | 0.098841   |   0.0 |  0.39
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.36616    | 0.36616    | 0.36616    |   0.0 |  1.46
Other   |            | 0.06151    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.236212315185, Press = 1.36017039645769
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17680.179   -17680.179   -17744.322   -17744.322    248.24343    248.24343    31310.349    31310.349   -4943.5963   -4943.5963 
   34000   -17681.004   -17681.004    -17746.11    -17746.11    251.96509    251.96509    31270.176    31270.176   -629.64382   -629.64382 
Loop time of 25.0053 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.455 ns/day, 6.946 hours/ns, 39.992 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    | 24.479     | 24.479     | 24.479     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099114   | 0.099114   | 0.099114   |   0.0 |  0.40
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.36569    | 0.36569    | 0.36569    |   0.0 |  1.46
Other   |            | 0.06088    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.318784190685, Press = 0.326875979974819
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17681.004   -17681.004    -17746.11    -17746.11    251.96509    251.96509    31270.176    31270.176   -629.64382   -629.64382 
   35000   -17677.515   -17677.515   -17745.359   -17745.359    262.56246    262.56246     31264.57     31264.57    695.18214    695.18214 
Loop time of 26.2237 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.295 ns/day, 7.284 hours/ns, 38.133 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    | 25.674     | 25.674     | 25.674     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10162    | 0.10162    | 0.10162    |   0.0 |  0.39
Output  | 0.0001563  | 0.0001563  | 0.0001563  |   0.0 |  0.00
Modify  | 0.38548    | 0.38548    | 0.38548    |   0.0 |  1.47
Other   |            | 0.06196    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.375017446239, Press = 0.58081373421959
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17677.515   -17677.515   -17745.359   -17745.359    262.56246    262.56246     31264.57     31264.57    695.18214    695.18214 
   36000   -17680.082   -17680.082   -17745.927   -17745.927    254.82765    254.82765    31253.328    31253.328    1943.3715    1943.3715 
Loop time of 25.4003 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.402 ns/day, 7.056 hours/ns, 39.370 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    | 24.87      | 24.87      | 24.87      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099148   | 0.099148   | 0.099148   |   0.0 |  0.39
Output  | 0.00020004 | 0.00020004 | 0.00020004 |   0.0 |  0.00
Modify  | 0.36946    | 0.36946    | 0.36946    |   0.0 |  1.45
Other   |            | 0.06154    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.346942856286, Press = 1.67946052094776
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17680.082   -17680.082   -17745.927   -17745.927    254.82765    254.82765    31253.328    31253.328    1943.3715    1943.3715 
   37000   -17681.145   -17681.145   -17745.707   -17745.707    249.86301    249.86301    31228.511    31228.511    3911.9934    3911.9934 
Loop time of 24.8717 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.474 ns/day, 6.909 hours/ns, 40.206 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    | 24.352     | 24.352     | 24.352     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098304   | 0.098304   | 0.098304   |   0.0 |  0.40
Output  | 0.00019752 | 0.00019752 | 0.00019752 |   0.0 |  0.00
Modify  | 0.36005    | 0.36005    | 0.36005    |   0.0 |  1.45
Other   |            | 0.06069    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.314716406046, Press = 1.31439483452344
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17681.145   -17681.145   -17745.707   -17745.707    249.86301    249.86301    31228.511    31228.511    3911.9934    3911.9934 
   38000   -17680.223   -17680.223   -17745.142   -17745.142    251.24311    251.24311    31268.603    31268.603    367.51078    367.51078 
Loop time of 25.0677 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.963 hours/ns, 39.892 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    | 24.543     | 24.543     | 24.543     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098555   | 0.098555   | 0.098555   |   0.0 |  0.39
Output  | 0.00019834 | 0.00019834 | 0.00019834 |   0.0 |  0.00
Modify  | 0.36509    | 0.36509    | 0.36509    |   0.0 |  1.46
Other   |            | 0.06095    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.386878201605, Press = 0.434002004226328
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17680.223   -17680.223   -17745.142   -17745.142    251.24311    251.24311    31268.603    31268.603    367.51078    367.51078 
   39000   -17678.222   -17678.222    -17744.88    -17744.88    257.97168    257.97168    31269.343    31269.343    391.37723    391.37723 
Loop time of 26.0638 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.315 ns/day, 7.240 hours/ns, 38.367 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    | 25.519     | 25.519     | 25.519     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10118    | 0.10118    | 0.10118    |   0.0 |  0.39
Output  | 0.0001589  | 0.0001589  | 0.0001589  |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  1.47
Other   |            | 0.06161    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.397317453895, Press = 2.93900870228395
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17678.222   -17678.222    -17744.88    -17744.88    257.97168    257.97168    31269.343    31269.343    391.37723    391.37723 
   40000   -17680.937   -17680.937   -17747.763   -17747.763    258.62318    258.62318    31261.683    31261.683   -237.81938   -237.81938 
Loop time of 25.1297 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.794 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    | 24.606     | 24.606     | 24.606     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097963   | 0.097963   | 0.097963   |   0.0 |  0.39
Output  | 0.00014689 | 0.00014689 | 0.00014689 |   0.0 |  0.00
Modify  | 0.36485    | 0.36485    | 0.36485    |   0.0 |  1.45
Other   |            | 0.06053    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.438729687118, Press = 0.0689124129646125
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17680.937   -17680.937   -17747.763   -17747.763    258.62318    258.62318    31261.683    31261.683   -237.81938   -237.81938 
   41000   -17677.274   -17677.274   -17742.718   -17742.718    253.27457    253.27457    31269.938    31269.938    1696.1828    1696.1828 
Loop time of 25.3351 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.410 ns/day, 7.038 hours/ns, 39.471 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    | 24.805     | 24.805     | 24.805     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098844   | 0.098844   | 0.098844   |   0.0 |  0.39
Output  | 0.00019452 | 0.00019452 | 0.00019452 |   0.0 |  0.00
Modify  | 0.3692     | 0.3692     | 0.3692     |   0.0 |  1.46
Other   |            | 0.06168    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.504052231736, Press = 1.31727973499276
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17677.274   -17677.274   -17742.718   -17742.718    253.27457    253.27457    31269.938    31269.938    1696.1828    1696.1828 
   42000   -17680.839   -17680.839   -17746.173   -17746.173    252.84828    252.84828    31266.591    31266.591   -867.74036   -867.74036 
Loop time of 25.1746 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.432 ns/day, 6.993 hours/ns, 39.723 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    | 24.648     | 24.648     | 24.648     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097766   | 0.097766   | 0.097766   |   0.0 |  0.39
Output  | 0.00015164 | 0.00015164 | 0.00015164 |   0.0 |  0.00
Modify  | 0.36698    | 0.36698    | 0.36698    |   0.0 |  1.46
Other   |            | 0.06187    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.498105917239, Press = 0.910375467688027
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17680.839   -17680.839   -17746.173   -17746.173    252.84828    252.84828    31266.591    31266.591   -867.74036   -867.74036 
   43000   -17679.662   -17679.662   -17744.608   -17744.608    251.34822    251.34822    31243.705    31243.705    3025.2023    3025.2023 
Loop time of 25.3274 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.411 ns/day, 7.035 hours/ns, 39.483 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    | 24.801     | 24.801     | 24.801     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098312   | 0.098312   | 0.098312   |   0.0 |  0.39
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.36677    | 0.36677    | 0.36677    |   0.0 |  1.45
Other   |            | 0.0612     |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.456034972643, Press = 1.97042187356706
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17679.662   -17679.662   -17744.608   -17744.608    251.34822    251.34822    31243.705    31243.705    3025.2023    3025.2023 
   44000   -17678.289   -17678.289   -17744.767   -17744.767    257.27389    257.27389    31275.783    31275.783   -454.62807   -454.62807 
Loop time of 25.4275 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.398 ns/day, 7.063 hours/ns, 39.328 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    | 24.894     | 24.894     | 24.894     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10007    | 0.10007    | 0.10007    |   0.0 |  0.39
Output  | 0.00015023 | 0.00015023 | 0.00015023 |   0.0 |  0.00
Modify  | 0.37221    | 0.37221    | 0.37221    |   0.0 |  1.46
Other   |            | 0.06141    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.417538763482, Press = 0.954948429670786
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17678.289   -17678.289   -17744.767   -17744.767    257.27389    257.27389    31275.783    31275.783   -454.62807   -454.62807 
   45000   -17678.248   -17678.248   -17743.486   -17743.486    252.47968    252.47968    31263.755    31263.755    1097.3147    1097.3147 
Loop time of 25.4539 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.394 ns/day, 7.071 hours/ns, 39.287 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    | 24.921     | 24.921     | 24.921     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099418   | 0.099418   | 0.099418   |   0.0 |  0.39
Output  | 0.00015322 | 0.00015322 | 0.00015322 |   0.0 |  0.00
Modify  | 0.37166    | 0.37166    | 0.37166    |   0.0 |  1.46
Other   |            | 0.06174    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.433913192512, Press = 0.32096635955695
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17678.248   -17678.248   -17743.486   -17743.486    252.47968    252.47968    31263.755    31263.755    1097.3147    1097.3147 
   46000   -17680.818   -17680.818   -17744.568   -17744.568    246.71895    246.71895    31279.762    31279.762   -856.59241   -856.59241 
Loop time of 25.1192 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.978 hours/ns, 39.810 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.59      | 24.59      | 24.59      |   0.0 | 97.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10004    | 0.10004    | 0.10004    |   0.0 |  0.40
Output  | 0.00020325 | 0.00020325 | 0.00020325 |   0.0 |  0.00
Modify  | 0.36774    | 0.36774    | 0.36774    |   0.0 |  1.46
Other   |            | 0.06092    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.477140429543, Press = 2.63457432913348
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17680.818   -17680.818   -17744.568   -17744.568    246.71895    246.71895    31279.762    31279.762   -856.59241   -856.59241 
   47000   -17680.572   -17680.572   -17745.518   -17745.518     251.3502     251.3502      31252.7      31252.7    1961.2498    1961.2498 
Loop time of 25.1337 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.982 hours/ns, 39.787 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    | 24.609     | 24.609     | 24.609     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09822    | 0.09822    | 0.09822    |   0.0 |  0.39
Output  | 0.00015153 | 0.00015153 | 0.00015153 |   0.0 |  0.00
Modify  | 0.36543    | 0.36543    | 0.36543    |   0.0 |  1.45
Other   |            | 0.06078    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.487388957763, Press = 0.383649255161985
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17680.572   -17680.572   -17745.518   -17745.518     251.3502     251.3502      31252.7      31252.7    1961.2498    1961.2498 
   48000   -17675.999   -17675.999   -17742.483   -17742.483    257.30065    257.30065    31264.446    31264.446    2317.3385    2317.3385 
Loop time of 25.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.338 ns/day, 7.190 hours/ns, 38.632 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    | 25.338     | 25.338     | 25.338     |   0.0 | 97.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10178    | 0.10178    | 0.10178    |   0.0 |  0.39
Output  | 0.00019796 | 0.00019796 | 0.00019796 |   0.0 |  0.00
Modify  | 0.38314    | 0.38314    | 0.38314    |   0.0 |  1.48
Other   |            | 0.06208    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.506301700486, Press = 1.61959570908767
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17675.999   -17675.999   -17742.483   -17742.483    257.30065    257.30065    31264.446    31264.446    2317.3385    2317.3385 
   49000    -17681.15    -17681.15   -17745.507   -17745.507    249.06969    249.06969      31282.2      31282.2   -1861.6131   -1861.6131 
Loop time of 25.0987 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.442 ns/day, 6.972 hours/ns, 39.843 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.573     | 24.573     | 24.573     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098354   | 0.098354   | 0.098354   |   0.0 |  0.39
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.36574    | 0.36574    | 0.36574    |   0.0 |  1.46
Other   |            | 0.06175    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.527094218263, Press = 0.0977159388612455
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    -17681.15    -17681.15   -17745.507   -17745.507    249.06969    249.06969      31282.2      31282.2   -1861.6131   -1861.6131 
   50000   -17677.804   -17677.804   -17744.012   -17744.012    256.23516    256.23516    31269.074    31269.074    958.16902    958.16902 
Loop time of 24.9436 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.464 ns/day, 6.929 hours/ns, 40.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.422     | 24.422     | 24.422     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097968   | 0.097968   | 0.097968   |   0.0 |  0.39
Output  | 0.00015257 | 0.00015257 | 0.00015257 |   0.0 |  0.00
Modify  | 0.36236    | 0.36236    | 0.36236    |   0.0 |  1.45
Other   |            | 0.06153    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.595502479519, Press = 1.02192114921186
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17677.804   -17677.804   -17744.012   -17744.012    256.23516    256.23516    31269.074    31269.074    958.16902    958.16902 
   51000   -17680.254   -17680.254   -17744.568   -17744.568    248.90338    248.90338    31287.345    31287.345   -1674.7936   -1674.7936 
Loop time of 24.9589 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.462 ns/day, 6.933 hours/ns, 40.066 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    | 24.436     | 24.436     | 24.436     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098175   | 0.098175   | 0.098175   |   0.0 |  0.39
Output  | 0.00015299 | 0.00015299 | 0.00015299 |   0.0 |  0.00
Modify  | 0.36296    | 0.36296    | 0.36296    |   0.0 |  1.45
Other   |            | 0.06161    |            |       |  0.25

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.580680603141, Press = 1.47053810058663
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17680.254   -17680.254   -17744.568   -17744.568    248.90338    248.90338    31287.345    31287.345   -1674.7936   -1674.7936 
   52000   -17682.203   -17682.203   -17747.433   -17747.433    252.44611    252.44611    31266.762    31266.762    -286.9355    -286.9355 
Loop time of 24.9972 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.456 ns/day, 6.944 hours/ns, 40.004 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    | 24.474     | 24.474     | 24.474     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098658   | 0.098658   | 0.098658   |   0.0 |  0.39
Output  | 0.0001611  | 0.0001611  | 0.0001611  |   0.0 |  0.00
Modify  | 0.36337    | 0.36337    | 0.36337    |   0.0 |  1.45
Other   |            | 0.06076    |            |       |  0.24

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.590655001534, Press = -0.279461516232754
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17682.203   -17682.203   -17747.433   -17747.433    252.44611    252.44611    31266.762    31266.762    -286.9355    -286.9355 
   53000   -17679.175   -17679.175   -17744.517   -17744.517    252.87774    252.87774    31251.455    31251.455    2067.6107    2067.6107 
Loop time of 25.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.368 ns/day, 7.125 hours/ns, 38.985 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    | 25.111     | 25.111     | 25.111     |   0.0 | 97.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10047    | 0.10047    | 0.10047    |   0.0 |  0.39
Output  | 0.00015581 | 0.00015581 | 0.00015581 |   0.0 |  0.00
Modify  | 0.37747    | 0.37747    | 0.37747    |   0.0 |  1.47
Other   |            | 0.06196    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.55829967106, Press = 1.67224281195282
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17679.175   -17679.175   -17744.517   -17744.517    252.87774    252.87774    31251.455    31251.455    2067.6107    2067.6107 
   54000    -17680.95    -17680.95    -17747.11    -17747.11    256.04663    256.04663    31276.456    31276.456   -1963.9878   -1963.9878 
Loop time of 24.9311 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.466 ns/day, 6.925 hours/ns, 40.111 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    | 24.411     | 24.411     | 24.411     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098369   | 0.098369   | 0.098369   |   0.0 |  0.39
Output  | 0.00019836 | 0.00019836 | 0.00019836 |   0.0 |  0.00
Modify  | 0.36102    | 0.36102    | 0.36102    |   0.0 |  1.45
Other   |            | 0.0608     |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.498395997781, Press = 1.31235773261012
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000    -17680.95    -17680.95    -17747.11    -17747.11    256.04663    256.04663    31276.456    31276.456   -1963.9878   -1963.9878 
   55000   -17681.735   -17681.735   -17746.875   -17746.875    252.09602    252.09602    31258.571    31258.571     841.6512     841.6512 
Loop time of 25.2147 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.004 hours/ns, 39.659 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    | 24.686     | 24.686     | 24.686     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098408   | 0.098408   | 0.098408   |   0.0 |  0.39
Output  | 0.00015388 | 0.00015388 | 0.00015388 |   0.0 |  0.00
Modify  | 0.36911    | 0.36911    | 0.36911    |   0.0 |  1.46
Other   |            | 0.06116    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.481508802788, Press = 1.88859970550028
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17681.735   -17681.735   -17746.875   -17746.875    252.09602    252.09602    31258.571    31258.571     841.6512     841.6512 
   56000   -17682.563   -17682.563   -17747.363   -17747.363    250.78365    250.78365    31266.221    31266.221    -327.2002    -327.2002 
Loop time of 25.1219 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.439 ns/day, 6.978 hours/ns, 39.806 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    | 24.597     | 24.597     | 24.597     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098411   | 0.098411   | 0.098411   |   0.0 |  0.39
Output  | 0.00015382 | 0.00015382 | 0.00015382 |   0.0 |  0.00
Modify  | 0.36467    | 0.36467    | 0.36467    |   0.0 |  1.45
Other   |            | 0.06138    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.474624312214, Press = 0.736881029257559
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17682.563   -17682.563   -17747.363   -17747.363    250.78365    250.78365    31266.221    31266.221    -327.2002    -327.2002 
   57000   -17679.563   -17679.563   -17744.866   -17744.866    252.72862    252.72862    31283.271    31283.271   -1905.8481   -1905.8481 
Loop time of 25.1414 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.437 ns/day, 6.984 hours/ns, 39.775 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    | 24.616     | 24.616     | 24.616     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097994   | 0.097994   | 0.097994   |   0.0 |  0.39
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.36594    | 0.36594    | 0.36594    |   0.0 |  1.46
Other   |            | 0.06084    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.421360427773, Press = 0.187321536598205
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17679.563   -17679.563   -17744.866   -17744.866    252.72862    252.72862    31283.271    31283.271   -1905.8481   -1905.8481 
   58000   -17681.167   -17681.167    -17745.35    -17745.35    248.39374    248.39374    31274.031    31274.031    -324.6882    -324.6882 
Loop time of 25.1513 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.986 hours/ns, 39.759 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    | 24.625     | 24.625     | 24.625     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098725   | 0.098725   | 0.098725   |   0.0 |  0.39
Output  | 0.00019869 | 0.00019869 | 0.00019869 |   0.0 |  0.00
Modify  | 0.365      | 0.365      | 0.365      |   0.0 |  1.45
Other   |            | 0.06185    |            |       |  0.25

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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 = 253.422365591481, Press = 0.539321241459152
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17681.167   -17681.167    -17745.35    -17745.35    248.39374    248.39374    31274.031    31274.031    -324.6882    -324.6882 
   59000   -17681.351   -17681.351   -17744.843   -17744.843    245.71784    245.71784    31265.384    31265.384    979.48933    979.48933 
Loop time of 25.6348 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.370 ns/day, 7.121 hours/ns, 39.009 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    | 25.097     | 25.097     | 25.097     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099742   | 0.099742   | 0.099742   |   0.0 |  0.39
Output  | 0.00020185 | 0.00020185 | 0.00020185 |   0.0 |  0.00
Modify  | 0.37585    | 0.37585    | 0.37585    |   0.0 |  1.47
Other   |            | 0.06171    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.4623219268, Press = 0.773170797080741
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17681.351   -17681.351   -17744.843   -17744.843    245.71784    245.71784    31265.384    31265.384    979.48933    979.48933 
   60000   -17679.543   -17679.543   -17746.409   -17746.409    258.77683    258.77683    31278.749    31278.749   -841.99429   -841.99429 
Loop time of 25.3714 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.405 ns/day, 7.048 hours/ns, 39.415 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    | 24.837     | 24.837     | 24.837     |   0.0 | 97.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10021    | 0.10021    | 0.10021    |   0.0 |  0.39
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.37191    | 0.37191    | 0.37191    |   0.0 |  1.47
Other   |            | 0.0622     |            |       |  0.25

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.465585222173, Press = 1.38807551173249
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17679.543   -17679.543   -17746.409   -17746.409    258.77683    258.77683    31278.749    31278.749   -841.99429   -841.99429 
   61000   -17681.051   -17681.051   -17744.594   -17744.594    245.91809    245.91809    31282.394    31282.394   -1716.6498   -1716.6498 
Loop time of 25.1513 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.986 hours/ns, 39.759 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    | 24.623     | 24.623     | 24.623     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097986   | 0.097986   | 0.097986   |   0.0 |  0.39
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.3686     | 0.3686     | 0.3686     |   0.0 |  1.47
Other   |            | 0.06143    |            |       |  0.24

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:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
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 = 253.411461017503, Press = -0.212268019319676
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -17681.051   -17681.051   -17744.594   -17744.594    245.91809    245.91809    31282.394    31282.394   -1716.6498   -1716.6498 
   62000   -17681.824   -17681.824   -17746.399   -17746.399    249.91164    249.91164    31263.015    31263.015    779.48306    779.48306 
Loop time of 24.9913 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.457 ns/day, 6.942 hours/ns, 40.014 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    | 24.47      | 24.47      | 24.47      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097028   | 0.097028   | 0.097028   |   0.0 |  0.39
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.36274    | 0.36274    | 0.36274    |   0.0 |  1.45
Other   |            | 0.0611     |            |       |  0.24

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:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
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 = 253.394262469613, Press = 1.50374331456096
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17681.824   -17681.824   -17746.399   -17746.399    249.91164    249.91164    31263.015    31263.015    779.48306    779.48306 
   63000   -17683.063   -17683.063   -17746.036   -17746.036    243.71245    243.71245    31267.999    31267.999   -200.71782   -200.71782 
Loop time of 25.0157 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.454 ns/day, 6.949 hours/ns, 39.975 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    | 24.49      | 24.49      | 24.49      |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098908   | 0.098908   | 0.098908   |   0.0 |  0.40
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.36557    | 0.36557    | 0.36557    |   0.0 |  1.46
Other   |            | 0.06138    |            |       |  0.25

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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.00200
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 = 253.389315646364, Press = 1.26405178457049
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 = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17683.063   -17683.063   -17746.036   -17746.036    243.71245    243.71245    31267.999    31267.999   -200.71782   -200.71782 
   64000   -17679.783   -17679.783   -17745.434   -17745.434    254.07515    254.07515    31273.627    31273.627    370.22963    370.22963 
Loop time of 24.7789 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.487 ns/day, 6.883 hours/ns, 40.357 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    | 24.26      | 24.26      | 24.26      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097004   | 0.097004   | 0.097004   |   0.0 |  0.39
Output  | 0.00016068 | 0.00016068 | 0.00016068 |   0.0 |  0.00
Modify  | 0.36077    | 0.36077    | 0.36077    |   0.0 |  1.46
Other   |            | 0.06054    |            |       |  0.24

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:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
31269.7573269075

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0