# 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.520000003278256*${_u_distance}
variable latticeconst_converted equal 3.520000003278256*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52000000327826
Lattice spacing in x,y,z = 3.5200000 3.5200000 3.5200000
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 (35.200000 35.200000 35.200000)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.200000 35.200000 35.200000)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_Wagner_2007_Ni__MO_444394830472_001
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43614.2081218568 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_444394830472_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17638.129   -17638.129       -17800       -17800       313.15       313.15    43614.208    43614.208    3964.2185    3964.2185 
    1000   -17467.709   -17467.709   -17629.921   -17629.921    313.80951    313.80951    43961.047    43961.047    1436.9736    1436.9736 
Loop time of 188.91 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.475 hours/ns, 5.294 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    | 187.98     | 187.98     | 187.98     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15266    | 0.15266    | 0.15266    |   0.0 |  0.08
Output  | 0.00022677 | 0.00022677 | 0.00022677 |   0.0 |  0.00
Modify  | 0.67695    | 0.67695    | 0.67695    |   0.0 |  0.36
Other   |            | 0.09627    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17467.709   -17467.709   -17629.921   -17629.921    313.80951    313.80951    43961.047    43961.047    1436.9736    1436.9736 
    2000   -17470.471   -17470.471   -17630.489   -17630.489    309.56513    309.56513    44004.885    44004.885   -623.22569   -623.22569 
Loop time of 201.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.052 hours/ns, 4.956 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    | 200.85     | 200.85     | 200.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15301    | 0.15301    | 0.15301    |   0.0 |  0.08
Output  | 0.00021293 | 0.00021293 | 0.00021293 |   0.0 |  0.00
Modify  | 0.68384    | 0.68384    | 0.68384    |   0.0 |  0.34
Other   |            | 0.09759    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314972.0 ave      314972 max      314972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314972
Ave neighs/atom = 78.743000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17470.471   -17470.471   -17630.489   -17630.489    309.56513    309.56513    44004.885    44004.885   -623.22569   -623.22569 
    3000   -17477.346   -17477.346   -17640.329   -17640.329     315.3033     315.3033    44014.537    44014.537   -1130.5514   -1130.5514 
Loop time of 201.112 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.864 hours/ns, 4.972 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    | 200.19     | 200.19     | 200.19     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15195    | 0.15195    | 0.15195    |   0.0 |  0.08
Output  | 0.00026626 | 0.00026626 | 0.00026626 |   0.0 |  0.00
Modify  | 0.67532    | 0.67532    | 0.67532    |   0.0 |  0.34
Other   |            | 0.0971     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314904.0 ave      314904 max      314904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314904
Ave neighs/atom = 78.726000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17477.346   -17477.346   -17640.329   -17640.329     315.3033     315.3033    44014.537    44014.537   -1130.5514   -1130.5514 
    4000   -17468.987   -17468.987   -17634.025   -17634.025    319.27647    319.27647    44012.452    44012.452   -967.17674   -967.17674 
Loop time of 202.194 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.165 hours/ns, 4.946 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    | 201.26     | 201.26     | 201.26     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15088    | 0.15088    | 0.15088    |   0.0 |  0.07
Output  | 0.00025383 | 0.00025383 | 0.00025383 |   0.0 |  0.00
Modify  | 0.68093    | 0.68093    | 0.68093    |   0.0 |  0.34
Other   |            | 0.09709    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314596.0 ave      314596 max      314596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314596
Ave neighs/atom = 78.649000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17468.987   -17468.987   -17634.025   -17634.025    319.27647    319.27647    44012.452    44012.452   -967.17674   -967.17674 
    5000   -17474.562   -17474.562   -17637.887   -17637.887    315.96321    315.96321    43952.995    43952.995    1169.1459    1169.1459 
Loop time of 200.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.741 hours/ns, 4.983 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    | 199.74     | 199.74     | 199.74     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15219    | 0.15219    | 0.15219    |   0.0 |  0.08
Output  | 0.00017909 | 0.00017909 | 0.00017909 |   0.0 |  0.00
Modify  | 0.67881    | 0.67881    | 0.67881    |   0.0 |  0.34
Other   |            | 0.09614    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314898.0 ave      314898 max      314898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314898
Ave neighs/atom = 78.724500
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 = 309.846591308335, Press = 760.422062967422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17474.562   -17474.562   -17637.887   -17637.887    315.96321    315.96321    43952.995    43952.995    1169.1459    1169.1459 
    6000   -17474.861   -17474.861   -17635.439   -17635.439    310.64916    310.64916    43954.363    43954.363    1401.0203    1401.0203 
Loop time of 201.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.894 hours/ns, 4.970 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    | 200.27     | 200.27     | 200.27     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.08
Output  | 0.00024586 | 0.00024586 | 0.00024586 |   0.0 |  0.00
Modify  | 0.70045    | 0.70045    | 0.70045    |   0.0 |  0.35
Other   |            | 0.09704    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315112.0 ave      315112 max      315112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315112
Ave neighs/atom = 78.778000
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 = 313.33828585772, Press = 24.7614756654046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17474.861   -17474.861   -17635.439   -17635.439    310.64916    310.64916    43954.363    43954.363    1401.0203    1401.0203 
    7000   -17469.375   -17469.375   -17634.158   -17634.158    318.78377    318.78377    43977.788    43977.788    530.84445    530.84445 
Loop time of 200.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.569 hours/ns, 4.999 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    | 199.11     | 199.11     | 199.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15166    | 0.15166    | 0.15166    |   0.0 |  0.08
Output  | 0.00023185 | 0.00023185 | 0.00023185 |   0.0 |  0.00
Modify  | 0.69532    | 0.69532    | 0.69532    |   0.0 |  0.35
Other   |            | 0.09552    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315088.0 ave      315088 max      315088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315088
Ave neighs/atom = 78.772000
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 = 313.158838072376, Press = -3.15480550235409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17469.375   -17469.375   -17634.158   -17634.158    318.78377    318.78377    43977.788    43977.788    530.84445    530.84445 
    8000   -17473.342   -17473.342   -17636.398   -17636.398     315.4417     315.4417    44032.895    44032.895   -1735.8785   -1735.8785 
Loop time of 200.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.601 hours/ns, 4.996 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    | 199.21     | 199.21     | 199.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.08
Output  | 0.00022552 | 0.00022552 | 0.00022552 |   0.0 |  0.00
Modify  | 0.69993    | 0.69993    | 0.69993    |   0.0 |  0.35
Other   |            | 0.09616    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314976.0 ave      314976 max      314976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314976
Ave neighs/atom = 78.744000
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 = 313.010582757395, Press = -6.82558454239402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17473.342   -17473.342   -17636.398   -17636.398     315.4417     315.4417    44032.895    44032.895   -1735.8785   -1735.8785 
    9000   -17472.198   -17472.198   -17630.487   -17630.487    306.22038    306.22038    44066.486    44066.486   -2701.0762   -2701.0762 
Loop time of 201.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.840 hours/ns, 4.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    | 200.07     | 200.07     | 200.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15169    | 0.15169    | 0.15169    |   0.0 |  0.08
Output  | 0.00018117 | 0.00018117 | 0.00018117 |   0.0 |  0.00
Modify  | 0.70245    | 0.70245    | 0.70245    |   0.0 |  0.35
Other   |            | 0.0963     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314680.0 ave      314680 max      314680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314680
Ave neighs/atom = 78.670000
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 = 313.248548545891, Press = 12.6645308634933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17472.198   -17472.198   -17630.487   -17630.487    306.22038    306.22038    44066.486    44066.486   -2701.0762   -2701.0762 
   10000   -17472.342   -17472.342   -17633.714   -17633.714    312.18354    312.18354    43988.001    43988.001    12.929898    12.929898 
Loop time of 201.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.846 hours/ns, 4.974 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    | 200.1      | 200.1      | 200.1      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1514     | 0.1514     | 0.1514     |   0.0 |  0.08
Output  | 0.00017455 | 0.00017455 | 0.00017455 |   0.0 |  0.00
Modify  | 0.69645    | 0.69645    | 0.69645    |   0.0 |  0.35
Other   |            | 0.09639    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314710.0 ave      314710 max      314710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314710
Ave neighs/atom = 78.677500
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 = 313.221876565175, Press = 15.6062654176096
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17472.342   -17472.342   -17633.714   -17633.714    312.18354    312.18354    43988.001    43988.001    12.929898    12.929898 
   11000   -17468.582   -17468.582   -17633.811   -17633.811    319.64577    319.64577    43978.123    43978.123     587.6603     587.6603 
Loop time of 202.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.264 hours/ns, 4.937 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    | 201.6      | 201.6      | 201.6      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15196    | 0.15196    | 0.15196    |   0.0 |  0.08
Output  | 0.0002275  | 0.0002275  | 0.0002275  |   0.0 |  0.00
Modify  | 0.70439    | 0.70439    | 0.70439    |   0.0 |  0.35
Other   |            | 0.09679    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314882.0 ave      314882 max      314882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314882
Ave neighs/atom = 78.720500
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 = 313.125462923475, Press = 7.62902609351765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17468.582   -17468.582   -17633.811   -17633.811    319.64577    319.64577    43978.123    43978.123     587.6603     587.6603 
   12000   -17475.374   -17475.374   -17634.883   -17634.883     308.5804     308.5804     43965.66     43965.66    814.79968    814.79968 
Loop time of 204.327 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.757 hours/ns, 4.894 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.37     | 203.37     | 203.37     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15342    | 0.15342    | 0.15342    |   0.0 |  0.08
Output  | 0.00017749 | 0.00017749 | 0.00017749 |   0.0 |  0.00
Modify  | 0.70916    | 0.70916    | 0.70916    |   0.0 |  0.35
Other   |            | 0.09821    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315028.0 ave      315028 max      315028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315028
Ave neighs/atom = 78.757000
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 = 313.321117548757, Press = 4.5639286709648
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17475.374   -17475.374   -17634.883   -17634.883     308.5804     308.5804     43965.66     43965.66    814.79968    814.79968 
   13000   -17469.742   -17469.742   -17635.665   -17635.665    320.98858    320.98858    43982.441    43982.441     260.5989     260.5989 
Loop time of 202.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.313 hours/ns, 4.933 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    | 201.76     | 201.76     | 201.76     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15312    | 0.15312    | 0.15312    |   0.0 |  0.08
Output  | 0.00022028 | 0.00022028 | 0.00022028 |   0.0 |  0.00
Modify  | 0.71191    | 0.71191    | 0.71191    |   0.0 |  0.35
Other   |            | 0.09735    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314886.0 ave      314886 max      314886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314886
Ave neighs/atom = 78.721500
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 = 313.388596157103, Press = -1.68210405566323
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17469.742   -17469.742   -17635.665   -17635.665    320.98858    320.98858    43982.441    43982.441     260.5989     260.5989 
   14000   -17474.971   -17474.971   -17634.192   -17634.192    308.02358    308.02358    44033.505    44033.505   -1845.8588   -1845.8588 
Loop time of 199.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.473 hours/ns, 5.007 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    | 198.76     | 198.76     | 198.76     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15017    | 0.15017    | 0.15017    |   0.0 |  0.08
Output  | 0.00017842 | 0.00017842 | 0.00017842 |   0.0 |  0.00
Modify  | 0.69779    | 0.69779    | 0.69779    |   0.0 |  0.35
Other   |            | 0.09667    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314966.0 ave      314966 max      314966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314966
Ave neighs/atom = 78.741500
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 = 313.376315933748, Press = -3.93746437809087
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17474.971   -17474.971   -17634.192   -17634.192    308.02358    308.02358    44033.505    44033.505   -1845.8588   -1845.8588 
   15000   -17474.058   -17474.058   -17633.803   -17633.803    309.03749    309.03749    44058.743    44058.743   -2716.4048   -2716.4048 
Loop time of 202.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.215 hours/ns, 4.941 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    | 201.42     | 201.42     | 201.42     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15253    | 0.15253    | 0.15253    |   0.0 |  0.08
Output  | 0.00017576 | 0.00017576 | 0.00017576 |   0.0 |  0.00
Modify  | 0.70807    | 0.70807    | 0.70807    |   0.0 |  0.35
Other   |            | 0.09718    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314776.0 ave      314776 max      314776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314776
Ave neighs/atom = 78.694000
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 = 313.604976558521, Press = 3.92756851942618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17474.058   -17474.058   -17633.803   -17633.803    309.03749    309.03749    44058.743    44058.743   -2716.4048   -2716.4048 
   16000   -17471.415   -17471.415   -17632.614   -17632.614    311.85011    311.85011    43996.939    43996.939   -169.17708   -169.17708 
Loop time of 201.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.920 hours/ns, 4.967 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    | 200.35     | 200.35     | 200.35     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.08
Output  | 0.00017827 | 0.00017827 | 0.00017827 |   0.0 |  0.00
Modify  | 0.70956    | 0.70956    | 0.70956    |   0.0 |  0.35
Other   |            | 0.0975     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314654.0 ave      314654 max      314654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314654
Ave neighs/atom = 78.663500
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 = 313.591261404987, Press = 4.30772173600496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17471.415   -17471.415   -17632.614   -17632.614    311.85011    311.85011    43996.939    43996.939   -169.17708   -169.17708 
   17000    -17472.88    -17472.88   -17634.673   -17634.673    312.99853    312.99853    43983.082    43983.082    127.48063    127.48063 
Loop time of 201.106 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.863 hours/ns, 4.972 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    | 200.16     | 200.16     | 200.16     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.08
Output  | 0.0001755  | 0.0001755  | 0.0001755  |   0.0 |  0.00
Modify  | 0.70281    | 0.70281    | 0.70281    |   0.0 |  0.35
Other   |            | 0.09586    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314922.0 ave      314922 max      314922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314922
Ave neighs/atom = 78.730500
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 = 313.652455043965, Press = 2.71032816624562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -17472.88    -17472.88   -17634.673   -17634.673    312.99853    312.99853    43983.082    43983.082    127.48063    127.48063 
   18000   -17476.503   -17476.503   -17636.974   -17636.974    310.44234    310.44234    43978.006    43978.006    310.14548    310.14548 
Loop time of 200.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.782 hours/ns, 4.980 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    | 199.87     | 199.87     | 199.87     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15056    | 0.15056    | 0.15056    |   0.0 |  0.07
Output  | 0.00017228 | 0.00017228 | 0.00017228 |   0.0 |  0.00
Modify  | 0.69623    | 0.69623    | 0.69623    |   0.0 |  0.35
Other   |            | 0.09629    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314974.0 ave      314974 max      314974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314974
Ave neighs/atom = 78.743500
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 = 313.628727920517, Press = 1.50778167278311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17476.503   -17476.503   -17636.974   -17636.974    310.44234    310.44234    43978.006    43978.006    310.14548    310.14548 
   19000   -17473.084   -17473.084   -17635.859   -17635.859    314.89876    314.89876    43988.065    43988.065   -24.089937   -24.089937 
Loop time of 201.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.934 hours/ns, 4.966 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    | 200.41     | 200.41     | 200.41     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.08
Output  | 0.00017524 | 0.00017524 | 0.00017524 |   0.0 |  0.00
Modify  | 0.7026     | 0.7026     | 0.7026     |   0.0 |  0.35
Other   |            | 0.09671    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314832.0 ave      314832 max      314832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314832
Ave neighs/atom = 78.708000
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 = 313.54336961442, Press = -0.186798137867526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17473.084   -17473.084   -17635.859   -17635.859    314.89876    314.89876    43988.065    43988.065   -24.089937   -24.089937 
   20000   -17468.226   -17468.226   -17634.414   -17634.414    321.50101    321.50101    44025.941    44025.941   -1367.7083   -1367.7083 
Loop time of 200.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.668 hours/ns, 4.990 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    | 199.46     | 199.46     | 199.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.08
Output  | 0.00017608 | 0.00017608 | 0.00017608 |   0.0 |  0.00
Modify  | 0.69582    | 0.69582    | 0.69582    |   0.0 |  0.35
Other   |            | 0.09724    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314840.0 ave      314840 max      314840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314840
Ave neighs/atom = 78.710000
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 = 313.479574353453, Press = 1.10600748022904
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17468.226   -17468.226   -17634.414   -17634.414    321.50101    321.50101    44025.941    44025.941   -1367.7083   -1367.7083 
   21000   -17473.012   -17473.012    -17635.98    -17635.98    315.27256    315.27256    44015.488    44015.488    -1081.154    -1081.154 
Loop time of 200.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.628 hours/ns, 4.993 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    | 199.32     | 199.32     | 199.32     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15091    | 0.15091    | 0.15091    |   0.0 |  0.08
Output  | 0.00018081 | 0.00018081 | 0.00018081 |   0.0 |  0.00
Modify  | 0.69587    | 0.69587    | 0.69587    |   0.0 |  0.35
Other   |            | 0.09641    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314688.0 ave      314688 max      314688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314688
Ave neighs/atom = 78.672000
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 = 313.500927998902, Press = 4.44311264176764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17473.012   -17473.012    -17635.98    -17635.98    315.27256    315.27256    44015.488    44015.488    -1081.154    -1081.154 
   22000   -17473.813   -17473.813    -17637.05    -17637.05    315.79201    315.79201    43948.976    43948.976    1535.4593    1535.4593 
Loop time of 202.24 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.178 hours/ns, 4.945 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    | 201.29     | 201.29     | 201.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15112    | 0.15112    | 0.15112    |   0.0 |  0.07
Output  | 0.00018014 | 0.00018014 | 0.00018014 |   0.0 |  0.00
Modify  | 0.70474    | 0.70474    | 0.70474    |   0.0 |  0.35
Other   |            | 0.09743    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314820.0 ave      314820 max      314820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314820
Ave neighs/atom = 78.705000
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 = 313.545037521629, Press = 4.5141905597678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17473.813   -17473.813    -17637.05    -17637.05    315.79201    315.79201    43948.976    43948.976    1535.4593    1535.4593 
   23000   -17470.344   -17470.344   -17633.245   -17633.245    315.14348    315.14348    43963.593    43963.593    1184.2079    1184.2079 
Loop time of 201.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.858 hours/ns, 4.973 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    | 200.15     | 200.15     | 200.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.07
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.69544    | 0.69544    | 0.69544    |   0.0 |  0.35
Other   |            | 0.09639    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314942.0 ave      314942 max      314942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314942
Ave neighs/atom = 78.735500
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 = 313.606047532609, Press = 1.10698226474013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17470.344   -17470.344   -17633.245   -17633.245    315.14348    315.14348    43963.593    43963.593    1184.2079    1184.2079 
   24000    -17469.02    -17469.02   -17633.742   -17633.742    318.66595    318.66595    43995.607    43995.607   -242.76075   -242.76075 
Loop time of 200.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.629 hours/ns, 4.993 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    | 199.32     | 199.32     | 199.32     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.08
Output  | 0.0001768  | 0.0001768  | 0.0001768  |   0.0 |  0.00
Modify  | 0.69371    | 0.69371    | 0.69371    |   0.0 |  0.35
Other   |            | 0.09595    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314900.0 ave      314900 max      314900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314900
Ave neighs/atom = 78.725000
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 = 313.58710098958, Press = 0.488702289546751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -17469.02    -17469.02   -17633.742   -17633.742    318.66595    318.66595    43995.607    43995.607   -242.76075   -242.76075 
   25000   -17475.819   -17475.819   -17635.819   -17635.819    309.53056    309.53056    43999.408    43999.408   -688.48265   -688.48265 
Loop time of 202.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.173 hours/ns, 4.945 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    | 201.26     | 201.26     | 201.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15223    | 0.15223    | 0.15223    |   0.0 |  0.08
Output  | 0.00017874 | 0.00017874 | 0.00017874 |   0.0 |  0.00
Modify  | 0.70891    | 0.70891    | 0.70891    |   0.0 |  0.35
Other   |            | 0.09679    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314968.0 ave      314968 max      314968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314968
Ave neighs/atom = 78.742000
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 = 313.683790921593, Press = 0.761205193899889
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17475.819   -17475.819   -17635.819   -17635.819    309.53056    309.53056    43999.408    43999.408   -688.48265   -688.48265 
   26000    -17475.33    -17475.33   -17635.863   -17635.863    310.56251    310.56251    44006.696    44006.696   -800.16573   -800.16573 
Loop time of 200.385 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.663 hours/ns, 4.990 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    | 199.43     | 199.43     | 199.43     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15153    | 0.15153    | 0.15153    |   0.0 |  0.08
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.70371    | 0.70371    | 0.70371    |   0.0 |  0.35
Other   |            | 0.09757    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314926.0 ave      314926 max      314926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314926
Ave neighs/atom = 78.731500
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 = 313.67749798265, Press = 1.37111969381607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -17475.33    -17475.33   -17635.863   -17635.863    310.56251    310.56251    44006.696    44006.696   -800.16573   -800.16573 
   27000   -17472.971   -17472.971   -17635.723   -17635.723    314.85494    314.85494    44001.119    44001.119   -643.45023   -643.45023 
Loop time of 200.07 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.575 hours/ns, 4.998 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.13     | 199.13     | 199.13     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15132    | 0.15132    | 0.15132    |   0.0 |  0.08
Output  | 0.00017657 | 0.00017657 | 0.00017657 |   0.0 |  0.00
Modify  | 0.6934     | 0.6934     | 0.6934     |   0.0 |  0.35
Other   |            | 0.09674    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314728.0 ave      314728 max      314728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314728
Ave neighs/atom = 78.682000
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 = 313.677808669572, Press = 2.18823788258411
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17472.971   -17472.971   -17635.723   -17635.723    314.85494    314.85494    44001.119    44001.119   -643.45023   -643.45023 
   28000   -17470.031   -17470.031   -17631.996   -17631.996     313.3329     313.3329    43975.588    43975.588    488.22155    488.22155 
Loop time of 200.418 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.672 hours/ns, 4.990 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    | 199.47     | 199.47     | 199.47     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15057    | 0.15057    | 0.15057    |   0.0 |  0.08
Output  | 0.00017212 | 0.00017212 | 0.00017212 |   0.0 |  0.00
Modify  | 0.6956     | 0.6956     | 0.6956     |   0.0 |  0.35
Other   |            | 0.09685    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314912.0 ave      314912 max      314912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314912
Ave neighs/atom = 78.728000
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 = 313.700893887388, Press = 2.17654493330491
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17470.031   -17470.031   -17631.996   -17631.996     313.3329     313.3329    43975.588    43975.588    488.22155    488.22155 
   29000   -17474.228   -17474.228   -17638.695   -17638.695    318.17272    318.17272    43949.667    43949.667    1358.8611    1358.8611 
Loop time of 200.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.824 hours/ns, 4.976 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    | 200.01     | 200.01     | 200.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15167    | 0.15167    | 0.15167    |   0.0 |  0.08
Output  | 0.00021846 | 0.00021846 | 0.00021846 |   0.0 |  0.00
Modify  | 0.70372    | 0.70372    | 0.70372    |   0.0 |  0.35
Other   |            | 0.09759    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314972.0 ave      314972 max      314972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314972
Ave neighs/atom = 78.743000
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 = 313.714242053139, Press = 1.53358391965815
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17474.228   -17474.228   -17638.695   -17638.695    318.17272    318.17272    43949.667    43949.667    1358.8611    1358.8611 
   30000   -17470.426   -17470.426   -17633.455   -17633.455    315.38945    315.38945    43959.457    43959.457    1302.8811    1302.8811 
Loop time of 200.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.799 hours/ns, 4.978 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    | 199.93     | 199.93     | 199.93     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15164    | 0.15164    | 0.15164    |   0.0 |  0.08
Output  | 0.00056166 | 0.00056166 | 0.00056166 |   0.0 |  0.00
Modify  | 0.70211    | 0.70211    | 0.70211    |   0.0 |  0.35
Other   |            | 0.09752    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314818.0 ave      314818 max      314818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314818
Ave neighs/atom = 78.704500
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 = 313.694821739282, Press = -0.961249808731222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17470.426   -17470.426   -17633.455   -17633.455    315.38945    315.38945    43959.457    43959.457    1302.8811    1302.8811 
   31000   -17474.336   -17474.336   -17633.606   -17633.606    308.11789    308.11789    44010.006    44010.006    -1048.742    -1048.742 
Loop time of 203.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.552 hours/ns, 4.912 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    | 202.62     | 202.62     | 202.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15312    | 0.15312    | 0.15312    |   0.0 |  0.08
Output  | 0.00017687 | 0.00017687 | 0.00017687 |   0.0 |  0.00
Modify  | 0.71205    | 0.71205    | 0.71205    |   0.0 |  0.35
Other   |            | 0.09712    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314910.0 ave      314910 max      314910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314910
Ave neighs/atom = 78.727500
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 = 313.596084723435, Press = -2.03126684470181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17474.336   -17474.336   -17633.606   -17633.606    308.11789    308.11789    44010.006    44010.006    -1048.742    -1048.742 
   32000   -17471.293   -17471.293   -17635.604   -17635.604    317.87057    317.87057    44027.592    44027.592   -1638.5259   -1638.5259 
Loop time of 200.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.780 hours/ns, 4.980 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    | 199.86     | 199.86     | 199.86     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15233    | 0.15233    | 0.15233    |   0.0 |  0.08
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.69613    | 0.69613    | 0.69613    |   0.0 |  0.35
Other   |            | 0.09603    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314860.0 ave      314860 max      314860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314860
Ave neighs/atom = 78.715000
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 = 313.62235833983, Press = 0.617481995888353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17471.293   -17471.293   -17635.604   -17635.604    317.87057    317.87057    44027.592    44027.592   -1638.5259   -1638.5259 
   33000    -17473.77    -17473.77   -17635.208   -17635.208    312.31242    312.31242    43991.546    43991.546   -226.90482   -226.90482 
Loop time of 202.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.226 hours/ns, 4.940 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    | 201.46     | 201.46     | 201.46     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15246    | 0.15246    | 0.15246    |   0.0 |  0.08
Output  | 0.00018017 | 0.00018017 | 0.00018017 |   0.0 |  0.00
Modify  | 0.7043     | 0.7043     | 0.7043     |   0.0 |  0.35
Other   |            | 0.09697    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314762.0 ave      314762 max      314762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314762
Ave neighs/atom = 78.690500
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 = 313.59451321629, Press = 1.37362741518677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -17473.77    -17473.77   -17635.208   -17635.208    312.31242    312.31242    43991.546    43991.546   -226.90482   -226.90482 
   34000   -17472.028   -17472.028   -17634.144   -17634.144    313.62351    313.62351    43977.318    43977.318    515.53648    515.53648 
Loop time of 202.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.221 hours/ns, 4.941 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    | 201.43     | 201.43     | 201.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.07
Output  | 0.00017747 | 0.00017747 | 0.00017747 |   0.0 |  0.00
Modify  | 0.70947    | 0.70947    | 0.70947    |   0.0 |  0.35
Other   |            | 0.09809    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314904.0 ave      314904 max      314904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314904
Ave neighs/atom = 78.726000
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 = 313.585515479424, Press = 1.72083809744188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17472.028   -17472.028   -17634.144   -17634.144    313.62351    313.62351    43977.318    43977.318    515.53648    515.53648 
   35000   -17475.242   -17475.242    -17634.64    -17634.64    308.36657    308.36657    43936.832    43936.832    2047.4644    2047.4644 
Loop time of 203.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.420 hours/ns, 4.923 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    | 202.15     | 202.15     | 202.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15184    | 0.15184    | 0.15184    |   0.0 |  0.07
Output  | 0.00035975 | 0.00035975 | 0.00035975 |   0.0 |  0.00
Modify  | 0.7082     | 0.7082     | 0.7082     |   0.0 |  0.35
Other   |            | 0.09816    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314988.0 ave      314988 max      314988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314988
Ave neighs/atom = 78.747000
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 = 313.56626157454, Press = 0.792758180176293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17475.242   -17475.242    -17634.64    -17634.64    308.36657    308.36657    43936.832    43936.832    2047.4644    2047.4644 
   36000   -17471.092   -17471.092   -17635.285   -17635.285    317.64236    317.64236    43962.589    43962.589    1060.3239    1060.3239 
Loop time of 202.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.161 hours/ns, 4.946 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    | 201.22     | 201.22     | 201.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15154    | 0.15154    | 0.15154    |   0.0 |  0.07
Output  | 0.00023325 | 0.00023325 | 0.00023325 |   0.0 |  0.00
Modify  | 0.71139    | 0.71139    | 0.71139    |   0.0 |  0.35
Other   |            | 0.09776    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314908.0 ave      314908 max      314908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314908
Ave neighs/atom = 78.727000
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 = 313.62759622666, Press = -1.51250658754547
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17471.092   -17471.092   -17635.285   -17635.285    317.64236    317.64236    43962.589    43962.589    1060.3239    1060.3239 
   37000   -17469.051   -17469.051    -17633.94    -17633.94    318.98949    318.98949    44036.798    44036.798   -1908.4212   -1908.4212 
Loop time of 203.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.543 hours/ns, 4.913 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    | 202.58     | 202.58     | 202.58     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1527     | 0.1527     | 0.1527     |   0.0 |  0.08
Output  | 0.00022782 | 0.00022782 | 0.00022782 |   0.0 |  0.00
Modify  | 0.71845    | 0.71845    | 0.71845    |   0.0 |  0.35
Other   |            | 0.09881    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314846.0 ave      314846 max      314846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314846
Ave neighs/atom = 78.711500
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 = 313.63256837504, Press = -1.14253491068883
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17469.051   -17469.051    -17633.94    -17633.94    318.98949    318.98949    44036.798    44036.798   -1908.4212   -1908.4212 
   38000   -17473.203   -17473.203   -17634.608   -17634.608    312.24743    312.24743    44031.874    44031.874    -1775.233    -1775.233 
Loop time of 200.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.824 hours/ns, 4.976 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    | 200.01     | 200.01     | 200.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15186    | 0.15186    | 0.15186    |   0.0 |  0.08
Output  | 0.000234   | 0.000234   | 0.000234   |   0.0 |  0.00
Modify  | 0.70272    | 0.70272    | 0.70272    |   0.0 |  0.35
Other   |            | 0.09656    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314752.0 ave      314752 max      314752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314752
Ave neighs/atom = 78.688000
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 = 313.640502284604, Press = 0.846531155378672
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17473.203   -17473.203   -17634.608   -17634.608    312.24743    312.24743    44031.874    44031.874    -1775.233    -1775.233 
   39000   -17469.744   -17469.744   -17633.806   -17633.806     317.3892     317.3892    44000.144    44000.144   -422.50933   -422.50933 
Loop time of 205.952 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.209 hours/ns, 4.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    | 204.98     | 204.98     | 204.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15308    | 0.15308    | 0.15308    |   0.0 |  0.07
Output  | 0.00017781 | 0.00017781 | 0.00017781 |   0.0 |  0.00
Modify  | 0.71817    | 0.71817    | 0.71817    |   0.0 |  0.35
Other   |            | 0.09793    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314832.0 ave      314832 max      314832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314832
Ave neighs/atom = 78.708000
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 = 313.616294689877, Press = 1.49790116090291
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17469.744   -17469.744   -17633.806   -17633.806     317.3892     317.3892    44000.144    44000.144   -422.50933   -422.50933 
   40000   -17477.699   -17477.699   -17637.611   -17637.611    309.36134    309.36134    43965.432    43965.432    667.75222    667.75222 
Loop time of 204.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.678 hours/ns, 4.901 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    | 203.07     | 203.07     | 203.07     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15216    | 0.15216    | 0.15216    |   0.0 |  0.07
Output  | 0.00017389 | 0.00017389 | 0.00017389 |   0.0 |  0.00
Modify  | 0.71728    | 0.71728    | 0.71728    |   0.0 |  0.35
Other   |            | 0.0981     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314832.0 ave      314832 max      314832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314832
Ave neighs/atom = 78.708000
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 = 313.562805330768, Press = 1.45313112710477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17477.699   -17477.699   -17637.611   -17637.611    309.36134    309.36134    43965.432    43965.432    667.75222    667.75222 
   41000   -17473.435   -17473.435   -17636.662   -17636.662    315.77317    315.77317    43963.458    43963.458     1075.931     1075.931 
Loop time of 198.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.229 hours/ns, 5.030 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    | 197.89     | 197.89     | 197.89     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14932    | 0.14932    | 0.14932    |   0.0 |  0.08
Output  | 0.00027291 | 0.00027291 | 0.00027291 |   0.0 |  0.00
Modify  | 0.68652    | 0.68652    | 0.68652    |   0.0 |  0.35
Other   |            | 0.09703    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314904.0 ave      314904 max      314904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314904
Ave neighs/atom = 78.726000
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 = 313.564019891486, Press = 0.562358392891511
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17473.435   -17473.435   -17636.662   -17636.662    315.77317    315.77317    43963.458    43963.458     1075.931     1075.931 
   42000   -17472.182   -17472.182   -17637.181   -17637.181    319.20158    319.20158    43983.466    43983.466    158.40849    158.40849 
Loop time of 203.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.652 hours/ns, 4.903 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    | 202.98     | 202.98     | 202.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15239    | 0.15239    | 0.15239    |   0.0 |  0.07
Output  | 0.00022545 | 0.00022545 | 0.00022545 |   0.0 |  0.00
Modify  | 0.71483    | 0.71483    | 0.71483    |   0.0 |  0.35
Other   |            | 0.09735    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314902.0 ave      314902 max      314902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314902
Ave neighs/atom = 78.725500
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 = 313.516875464147, Press = -0.767640949915114
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17472.182   -17472.182   -17637.181   -17637.181    319.20158    319.20158    43983.466    43983.466    158.40849    158.40849 
   43000   -17474.433   -17474.433   -17637.063   -17637.063    314.61934    314.61934    44050.478    44050.478    -2566.363    -2566.363 
Loop time of 206.58 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.383 hours/ns, 4.841 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    | 205.59     | 205.59     | 205.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15382    | 0.15382    | 0.15382    |   0.0 |  0.07
Output  | 0.00022367 | 0.00022367 | 0.00022367 |   0.0 |  0.00
Modify  | 0.73242    | 0.73242    | 0.73242    |   0.0 |  0.35
Other   |            | 0.0991     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314798.0 ave      314798 max      314798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314798
Ave neighs/atom = 78.699500
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 = 313.446034187211, Press = -0.266742474771071
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17474.433   -17474.433   -17637.063   -17637.063    314.61934    314.61934    44050.478    44050.478    -2566.363    -2566.363 
   44000   -17475.669   -17475.669    -17634.98    -17634.98    308.19851    308.19851    44036.601    44036.601   -1892.3887   -1892.3887 
Loop time of 205.606 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.113 hours/ns, 4.864 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    | 204.63     | 204.63     | 204.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15294    | 0.15294    | 0.15294    |   0.0 |  0.07
Output  | 0.00024125 | 0.00024125 | 0.00024125 |   0.0 |  0.00
Modify  | 0.72724    | 0.72724    | 0.72724    |   0.0 |  0.35
Other   |            | 0.0986     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314618.0 ave      314618 max      314618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314618
Ave neighs/atom = 78.654500
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 = 313.426602199347, Press = 1.45075859843567
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17475.669   -17475.669    -17634.98    -17634.98    308.19851    308.19851    44036.601    44036.601   -1892.3887   -1892.3887 
   45000   -17471.983   -17471.983   -17634.578   -17634.578    314.55207    314.55207    43985.433    43985.433    127.99507    127.99507 
Loop time of 207.151 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.542 hours/ns, 4.827 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.17     | 206.17     | 206.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15367    | 0.15367    | 0.15367    |   0.0 |  0.07
Output  | 0.00023386 | 0.00023386 | 0.00023386 |   0.0 |  0.00
Modify  | 0.72532    | 0.72532    | 0.72532    |   0.0 |  0.35
Other   |            | 0.09888    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314750.0 ave      314750 max      314750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314750
Ave neighs/atom = 78.687500
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 = 313.482347170615, Press = 1.64993904250549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17471.983   -17471.983   -17634.578   -17634.578    314.55207    314.55207    43985.433    43985.433    127.99507    127.99507 
   46000   -17470.398   -17470.398   -17632.638   -17632.638    313.86331    313.86331    43968.072    43968.072    958.47504    958.47504 
Loop time of 205.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.994 hours/ns, 4.874 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    | 204.2      | 204.2      | 204.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15341    | 0.15341    | 0.15341    |   0.0 |  0.07
Output  | 0.00022093 | 0.00022093 | 0.00022093 |   0.0 |  0.00
Modify  | 0.7232     | 0.7232     | 0.7232     |   0.0 |  0.35
Other   |            | 0.09828    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314906.0 ave      314906 max      314906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314906
Ave neighs/atom = 78.726500
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 = 313.47615521058, Press = 1.07460499147776
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17470.398   -17470.398   -17632.638   -17632.638    313.86331    313.86331    43968.072    43968.072    958.47504    958.47504 
   47000   -17473.478   -17473.478    -17634.89    -17634.89    312.26273    312.26273    43951.013    43951.013    1627.5709    1627.5709 
Loop time of 204.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.853 hours/ns, 4.886 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    | 203.7      | 203.7      | 203.7      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15351    | 0.15351    | 0.15351    |   0.0 |  0.08
Output  | 0.00017977 | 0.00017977 | 0.00017977 |   0.0 |  0.00
Modify  | 0.7149     | 0.7149     | 0.7149     |   0.0 |  0.35
Other   |            | 0.09826    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314946.0 ave      314946 max      314946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314946
Ave neighs/atom = 78.736500
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 = 313.485404409881, Press = 0.499085578794533
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17473.478   -17473.478    -17634.89    -17634.89    312.26273    312.26273    43951.013    43951.013    1627.5709    1627.5709 
   48000   -17470.166   -17470.166   -17635.747   -17635.747    320.32765    320.32765    43963.983    43963.983     1083.864     1083.864 
Loop time of 205.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.138 hours/ns, 4.862 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    | 204.72     | 204.72     | 204.72     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15265    | 0.15265    | 0.15265    |   0.0 |  0.07
Output  | 0.00018769 | 0.00018769 | 0.00018769 |   0.0 |  0.00
Modify  | 0.72521    | 0.72521    | 0.72521    |   0.0 |  0.35
Other   |            | 0.09854    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314934.0 ave      314934 max      314934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314934
Ave neighs/atom = 78.733500
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 = 313.522085214674, Press = -0.210422199113137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17470.166   -17470.166   -17635.747   -17635.747    320.32765    320.32765    43963.983    43963.983     1083.864     1083.864 
   49000   -17470.221   -17470.221   -17635.597   -17635.597    319.93032    319.93032    43995.983    43995.983   -224.55863   -224.55863 
Loop time of 205.033 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.954 hours/ns, 4.877 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    | 204.06     | 204.06     | 204.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15326    | 0.15326    | 0.15326    |   0.0 |  0.07
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.72256    | 0.72256    | 0.72256    |   0.0 |  0.35
Other   |            | 0.09917    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314826.0 ave      314826 max      314826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314826
Ave neighs/atom = 78.706500
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 = 313.512902617056, Press = -0.102024811128409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17470.221   -17470.221   -17635.597   -17635.597    319.93032    319.93032    43995.983    43995.983   -224.55863   -224.55863 
   50000   -17473.956   -17473.956   -17634.325   -17634.325    310.24417    310.24417    44021.451    44021.451   -1403.2881   -1403.2881 
Loop time of 208.282 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.856 hours/ns, 4.801 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    | 207.29     | 207.29     | 207.29     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15589    | 0.15589    | 0.15589    |   0.0 |  0.07
Output  | 0.00023015 | 0.00023015 | 0.00023015 |   0.0 |  0.00
Modify  | 0.73861    | 0.73861    | 0.73861    |   0.0 |  0.35
Other   |            | 0.09999    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314828.0 ave      314828 max      314828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314828
Ave neighs/atom = 78.707000
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 = 313.457708147939, Press = 0.0846971466178222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17473.956   -17473.956   -17634.325   -17634.325    310.24417    310.24417    44021.451    44021.451   -1403.2881   -1403.2881 
   51000   -17476.042   -17476.042   -17636.837   -17636.837    311.06849    311.06849    44024.181    44024.181   -1654.3345   -1654.3345 
Loop time of 204.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.828 hours/ns, 4.888 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.61     | 203.61     | 203.61     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15235    | 0.15235    | 0.15235    |   0.0 |  0.07
Output  | 0.00017919 | 0.00017919 | 0.00017919 |   0.0 |  0.00
Modify  | 0.72395    | 0.72395    | 0.72395    |   0.0 |  0.35
Other   |            | 0.09889    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314742.0 ave      314742 max      314742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314742
Ave neighs/atom = 78.685500
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 = 313.436590874935, Press = 1.41104062930836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17476.042   -17476.042   -17636.837   -17636.837    311.06849    311.06849    44024.181    44024.181   -1654.3345   -1654.3345 
   52000   -17471.172   -17471.172   -17634.852   -17634.852    316.64997    316.64997    43939.478    43939.478    2042.0331    2042.0331 
Loop time of 201.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.860 hours/ns, 4.973 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    | 200.15     | 200.15     | 200.15     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14989    | 0.14989    | 0.14989    |   0.0 |  0.07
Output  | 0.00017405 | 0.00017405 | 0.00017405 |   0.0 |  0.00
Modify  | 0.70241    | 0.70241    | 0.70241    |   0.0 |  0.35
Other   |            | 0.09775    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314680.0 ave      314680 max      314680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314680
Ave neighs/atom = 78.670000
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 = 313.41930550371, Press = 3.06102170953933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17471.172   -17471.172   -17634.852   -17634.852    316.64997    316.64997    43939.478    43939.478    2042.0331    2042.0331 
   53000   -17473.921   -17473.921    -17636.34    -17636.34    314.21126    314.21126    43948.388    43948.388    1444.2039    1444.2039 
Loop time of 203.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.583 hours/ns, 4.909 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    | 202.73     | 202.73     | 202.73     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15116    | 0.15116    | 0.15116    |   0.0 |  0.07
Output  | 0.00017843 | 0.00017843 | 0.00017843 |   0.0 |  0.00
Modify  | 0.71301    | 0.71301    | 0.71301    |   0.0 |  0.35
Other   |            | 0.09886    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315022.0 ave      315022 max      315022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315022
Ave neighs/atom = 78.755500
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 = 313.365898406078, Press = 0.548430457527044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17473.921   -17473.921    -17636.34    -17636.34    314.21126    314.21126    43948.388    43948.388    1444.2039    1444.2039 
   54000   -17474.082   -17474.082   -17633.524   -17633.524     308.4511     308.4511    43978.526    43978.526     325.3856     325.3856 
Loop time of 206.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.432 hours/ns, 4.837 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    | 205.78     | 205.78     | 205.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15308    | 0.15308    | 0.15308    |   0.0 |  0.07
Output  | 0.00017967 | 0.00017967 | 0.00017967 |   0.0 |  0.00
Modify  | 0.72694    | 0.72694    | 0.72694    |   0.0 |  0.35
Other   |            | 0.09968    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314850.0 ave      314850 max      314850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314850
Ave neighs/atom = 78.712500
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 = 313.36993503679, Press = 0.0659245281714792
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17474.082   -17474.082   -17633.524   -17633.524     308.4511     308.4511    43978.526    43978.526     325.3856     325.3856 
   55000    -17472.46    -17472.46   -17635.807   -17635.807      316.005      316.005    43997.991    43997.991   -330.09045   -330.09045 
Loop time of 207.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.639 hours/ns, 4.819 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    | 206.52     | 206.52     | 206.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.07
Output  | 0.00018215 | 0.00018215 | 0.00018215 |   0.0 |  0.00
Modify  | 0.72996    | 0.72996    | 0.72996    |   0.0 |  0.35
Other   |            | 0.0994     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315030.0 ave      315030 max      315030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315030
Ave neighs/atom = 78.757500
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 = 313.351026328784, Press = 0.481227157809107
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000    -17472.46    -17472.46   -17635.807   -17635.807      316.005      316.005    43997.991    43997.991   -330.09045   -330.09045 
   56000   -17477.063   -17477.063   -17637.329   -17637.329    310.04561    310.04561    43997.406    43997.406   -571.32866   -571.32866 
Loop time of 201.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.851 hours/ns, 4.974 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    | 200.11     | 200.11     | 200.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14913    | 0.14913    | 0.14913    |   0.0 |  0.07
Output  | 0.0001825  | 0.0001825  | 0.0001825  |   0.0 |  0.00
Modify  | 0.7067     | 0.7067     | 0.7067     |   0.0 |  0.35
Other   |            | 0.0983     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314774.0 ave      314774 max      314774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314774
Ave neighs/atom = 78.693500
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 = 313.299702256961, Press = 0.719828289223191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17477.063   -17477.063   -17637.329   -17637.329    310.04561    310.04561    43997.406    43997.406   -571.32866   -571.32866 
   57000   -17475.404   -17475.404   -17635.906   -17635.906    310.50191    310.50191     43978.11     43978.11      450.465      450.465 
Loop time of 206.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.450 hours/ns, 4.835 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    | 205.83     | 205.83     | 205.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.07
Output  | 0.0001839  | 0.0001839  | 0.0001839  |   0.0 |  0.00
Modify  | 0.73109    | 0.73109    | 0.73109    |   0.0 |  0.35
Other   |            | 0.09988    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314792.0 ave      314792 max      314792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314792
Ave neighs/atom = 78.698000
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 = 313.28469552098, Press = 1.26021582227652
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17475.404   -17475.404   -17635.906   -17635.906    310.50191    310.50191     43978.11     43978.11      450.465      450.465 
   58000   -17471.739   -17471.739   -17633.532   -17633.532    313.00056    313.00056    43937.606    43937.606    2067.7688    2067.7688 
Loop time of 208.281 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.856 hours/ns, 4.801 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    | 207.29     | 207.29     | 207.29     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15315    | 0.15315    | 0.15315    |   0.0 |  0.07
Output  | 0.00021753 | 0.00021753 | 0.00021753 |   0.0 |  0.00
Modify  | 0.73457    | 0.73457    | 0.73457    |   0.0 |  0.35
Other   |            | 0.1002     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314738.0 ave      314738 max      314738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314738
Ave neighs/atom = 78.684500
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 = 313.246547819442, Press = 0.424441990556882
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17471.739   -17471.739   -17633.532   -17633.532    313.00056    313.00056    43937.606    43937.606    2067.7688    2067.7688 
   59000   -17474.669   -17474.669   -17635.525   -17635.525    311.18677    311.18677    43955.022    43955.022    1175.2373    1175.2373 
Loop time of 204.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.670 hours/ns, 4.902 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    | 203.05     | 203.05     | 203.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15181    | 0.15181    | 0.15181    |   0.0 |  0.07
Output  | 0.00022277 | 0.00022277 | 0.00022277 |   0.0 |  0.00
Modify  | 0.71609    | 0.71609    | 0.71609    |   0.0 |  0.35
Other   |            | 0.09947    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315046.0 ave      315046 max      315046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315046
Ave neighs/atom = 78.761500
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 = 313.236133512656, Press = -0.437935350478207
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17474.669   -17474.669   -17635.525   -17635.525    311.18677    311.18677    43955.022    43955.022    1175.2373    1175.2373 
   60000   -17477.036   -17477.036   -17638.217   -17638.217     311.8141     311.8141    44009.653    44009.653   -1152.8629   -1152.8629 
Loop time of 205.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.191 hours/ns, 4.857 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    | 204.91     | 204.91     | 204.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15263    | 0.15263    | 0.15263    |   0.0 |  0.07
Output  | 0.00017665 | 0.00017665 | 0.00017665 |   0.0 |  0.00
Modify  | 0.7247     | 0.7247     | 0.7247     |   0.0 |  0.35
Other   |            | 0.09908    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      315004.0 ave      315004 max      315004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315004
Ave neighs/atom = 78.751000
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 = 313.214136021856, Press = -0.558441609020813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17477.036   -17477.036   -17638.217   -17638.217     311.8141     311.8141    44009.653    44009.653   -1152.8629   -1152.8629 
   61000   -17472.391   -17472.391   -17634.242   -17634.242    313.11104    313.11104    44013.492    44013.492   -1001.1123   -1001.1123 
Loop time of 205.391 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.053 hours/ns, 4.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    | 204.42     | 204.42     | 204.42     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15324    | 0.15324    | 0.15324    |   0.0 |  0.07
Output  | 0.00018568 | 0.00018568 | 0.00018568 |   0.0 |  0.00
Modify  | 0.72152    | 0.72152    | 0.72152    |   0.0 |  0.35
Other   |            | 0.09918    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314734.0 ave      314734 max      314734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314734
Ave neighs/atom = 78.683500
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 = 313.189191225989, Press = 0.582042922395783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -17472.391   -17472.391   -17634.242   -17634.242    313.11104    313.11104    44013.492    44013.492   -1001.1123   -1001.1123 
   62000   -17473.371   -17473.371   -17634.603   -17634.603     311.9144     311.9144    43983.633    43983.633    299.24645    299.24645 
Loop time of 205.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.088 hours/ns, 4.866 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.54     | 204.54     | 204.54     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15159    | 0.15159    | 0.15159    |   0.0 |  0.07
Output  | 0.00017683 | 0.00017683 | 0.00017683 |   0.0 |  0.00
Modify  | 0.71963    | 0.71963    | 0.71963    |   0.0 |  0.35
Other   |            | 0.09909    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314828.0 ave      314828 max      314828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314828
Ave neighs/atom = 78.707000
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 = 313.183700037628, Press = 0.774839913297046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17473.371   -17473.371   -17634.603   -17634.603     311.9144     311.9144    43983.633    43983.633    299.24645    299.24645 
   63000   -17476.386   -17476.386   -17637.887   -17637.887    312.43521    312.43521    43969.124    43969.124    554.56068    554.56068 
Loop time of 206.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.248 hours/ns, 4.852 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    | 205.11     | 205.11     | 205.11     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15177    | 0.15177    | 0.15177    |   0.0 |  0.07
Output  | 0.00018008 | 0.00018008 | 0.00018008 |   0.0 |  0.00
Modify  | 0.72745    | 0.72745    | 0.72745    |   0.0 |  0.35
Other   |            | 0.09932    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314824.0 ave      314824 max      314824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314824
Ave neighs/atom = 78.706000
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 = 313.184643349855, Press = 0.405435790558005
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17476.386   -17476.386   -17637.887   -17637.887    312.43521    312.43521    43969.124    43969.124    554.56068    554.56068 
   64000   -17475.061   -17475.061   -17636.317   -17636.317    311.95922    311.95922    43970.662    43970.662    599.53899    599.53899 
Loop time of 207.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.721 hours/ns, 4.812 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    | 206.8      | 206.8      | 206.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15452    | 0.15452    | 0.15452    |   0.0 |  0.07
Output  | 0.00022508 | 0.00022508 | 0.00022508 |   0.0 |  0.00
Modify  | 0.73904    | 0.73904    | 0.73904    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314820.0 ave      314820 max      314820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314820
Ave neighs/atom = 78.705000
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 = 313.177481007937, Press = -0.274271467906974
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17475.061   -17475.061   -17636.317   -17636.317    311.95922    311.95922    43970.662    43970.662    599.53899    599.53899 
   65000   -17475.458   -17475.458   -17637.169   -17637.169    312.84073    312.84073    44044.957    44044.957   -2389.6833   -2389.6833 
Loop time of 205.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.218 hours/ns, 4.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    | 205.01     | 205.01     | 205.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15246    | 0.15246    | 0.15246    |   0.0 |  0.07
Output  | 0.00017704 | 0.00017704 | 0.00017704 |   0.0 |  0.00
Modify  | 0.72576    | 0.72576    | 0.72576    |   0.0 |  0.35
Other   |            | 0.09875    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314822.0 ave      314822 max      314822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314822
Ave neighs/atom = 78.705500
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 = 313.190698569971, Press = -0.368151705246817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17475.458   -17475.458   -17637.169   -17637.169    312.84073    312.84073    44044.957    44044.957   -2389.6833   -2389.6833 
   66000   -17469.616   -17469.616   -17631.326   -17631.326    312.83987    312.83987    44040.241    44040.241   -1796.9959   -1796.9959 
Loop time of 206.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.307 hours/ns, 4.847 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    | 205.32     | 205.32     | 205.32     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15471    | 0.15471    | 0.15471    |   0.0 |  0.07
Output  | 0.00017845 | 0.00017845 | 0.00017845 |   0.0 |  0.00
Modify  | 0.73136    | 0.73136    | 0.73136    |   0.0 |  0.35
Other   |            | 0.09986    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314704.0 ave      314704 max      314704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314704
Ave neighs/atom = 78.676000
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 = 313.191911921649, Press = 0.982846307249068
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -17469.616   -17469.616   -17631.326   -17631.326    312.83987    312.83987    44040.241    44040.241   -1796.9959   -1796.9959 
   67000   -17473.227   -17473.227   -17632.802   -17632.802    308.70898    308.70898    43979.618    43979.618    363.71913    363.71913 
Loop time of 201.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.079 hours/ns, 4.953 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    | 200.92     | 200.92     | 200.92     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15099    | 0.15099    | 0.15099    |   0.0 |  0.07
Output  | 0.00017629 | 0.00017629 | 0.00017629 |   0.0 |  0.00
Modify  | 0.70802    | 0.70802    | 0.70802    |   0.0 |  0.35
Other   |            | 0.09857    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314744.0 ave      314744 max      314744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314744
Ave neighs/atom = 78.686000
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 = 313.183252990765, Press = 0.957569528606348
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -17473.227   -17473.227   -17632.802   -17632.802    308.70898    308.70898    43979.618    43979.618    363.71913    363.71913 
   68000   -17476.575   -17476.575   -17636.651   -17636.651    309.67785    309.67785    43961.206    43961.206    941.79056    941.79056 
Loop time of 204.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.678 hours/ns, 4.901 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    | 203.08     | 203.08     | 203.08     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15186    | 0.15186    | 0.15186    |   0.0 |  0.07
Output  | 0.00027593 | 0.00027593 | 0.00027593 |   0.0 |  0.00
Modify  | 0.71448    | 0.71448    | 0.71448    |   0.0 |  0.35
Other   |            | 0.09877    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314930.0 ave      314930 max      314930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314930
Ave neighs/atom = 78.732500
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 = 313.178831728354, Press = 0.415498817161307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -17476.575   -17476.575   -17636.651   -17636.651    309.67785    309.67785    43961.206    43961.206    941.79056    941.79056 
   69000   -17474.867   -17474.867   -17636.395   -17636.395    312.48747    312.48747    43979.007    43979.007    239.37427    239.37427 
Loop time of 208.313 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.415 ns/day, 57.865 hours/ns, 4.800 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    | 207.32     | 207.32     | 207.32     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15405    | 0.15405    | 0.15405    |   0.0 |  0.07
Output  | 0.00017517 | 0.00017517 | 0.00017517 |   0.0 |  0.00
Modify  | 0.73962    | 0.73962    | 0.73962    |   0.0 |  0.36
Other   |            | 0.1003     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 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:      314888.0 ave      314888 max      314888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314888
Ave neighs/atom = 78.722000
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
43987.6590903232

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0