# 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.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
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 (36.133157 36.133157 36.133157)
  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 (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdCu__MO_353393547686_001
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6305927869 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_353393547686_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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13998.129   -13998.129       -14160       -14160       313.15       313.15    47175.631    47175.631    3664.9605    3664.9605 
    1000   -13827.921   -13827.921   -13993.569   -13993.569    320.45756    320.45756    48028.204    48028.204   -1241.1996   -1241.1996 
Loop time of 262.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.926 hours/ns, 3.809 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 261.62     | 261.62     | 261.62     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.06
Output  | 0.00022402 | 0.00022402 | 0.00022402 |   0.0 |  0.00
Modify  | 0.66833    | 0.66833    | 0.66833    |   0.0 |  0.25
Other   |            | 0.09635    |            |       |  0.04

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:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13827.921   -13827.921   -13993.569   -13993.569    320.45756    320.45756    48028.204    48028.204   -1241.1996   -1241.1996 
    2000   -13839.016   -13839.016   -14001.672   -14001.672    314.66873    314.66873    47992.242    47992.242   -1071.7604   -1071.7604 
Loop time of 305.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.789 hours/ns, 3.276 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    | 304.16     | 304.16     | 304.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16267    | 0.16267    | 0.16267    |   0.0 |  0.05
Output  | 0.00021702 | 0.00021702 | 0.00021702 |   0.0 |  0.00
Modify  | 0.80542    | 0.80542    | 0.80542    |   0.0 |  0.26
Other   |            | 0.1085     |            |       |  0.04

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:      343472.0 ave      343472 max      343472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343472
Ave neighs/atom = 85.868000
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.016   -13839.016   -14001.672   -14001.672    314.66873    314.66873    47992.242    47992.242   -1071.7604   -1071.7604 
    3000   -13835.771   -13835.771   -14001.546   -14001.546    320.70365    320.70365    47954.874    47954.874    240.85463    240.85463 
Loop time of 282.854 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.571 hours/ns, 3.535 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    | 281.86     | 281.86     | 281.86     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15701    | 0.15701    | 0.15701    |   0.0 |  0.06
Output  | 0.00025036 | 0.00025036 | 0.00025036 |   0.0 |  0.00
Modify  | 0.73058    | 0.73058    | 0.73058    |   0.0 |  0.26
Other   |            | 0.1014     |            |       |  0.04

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:      343480.0 ave      343480 max      343480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343480
Ave neighs/atom = 85.870000
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.771   -13835.771   -14001.546   -14001.546    320.70365    320.70365    47954.874    47954.874    240.85463    240.85463 
    4000   -13835.538   -13835.538   -13997.886   -13997.886    314.07445    314.07445    47999.191    47999.191   -776.20453   -776.20453 
Loop time of 273.977 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.105 hours/ns, 3.650 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    | 273.05     | 273.05     | 273.05     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14847    | 0.14847    | 0.14847    |   0.0 |  0.05
Output  | 0.00027104 | 0.00027104 | 0.00027104 |   0.0 |  0.00
Modify  | 0.68089    | 0.68089    | 0.68089    |   0.0 |  0.25
Other   |            | 0.09931    |            |       |  0.04

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:      343652.0 ave      343652 max      343652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343652
Ave neighs/atom = 85.913000
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.538   -13835.538   -13997.886   -13997.886    314.07445    314.07445    47999.191    47999.191   -776.20453   -776.20453 
    5000   -13839.845   -13839.845   -13996.818   -13996.818    303.67417    303.67417    47969.938    47969.938    163.71553    163.71553 
Loop time of 304.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.701 hours/ns, 3.279 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    | 303.85     | 303.85     | 303.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16257    | 0.16257    | 0.16257    |   0.0 |  0.05
Output  | 0.00017811 | 0.00017811 | 0.00017811 |   0.0 |  0.00
Modify  | 0.80065    | 0.80065    | 0.80065    |   0.0 |  0.26
Other   |            | 0.1077     |            |       |  0.04

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:      343492.0 ave      343492 max      343492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343492
Ave neighs/atom = 85.873000
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 = 312.886414952777, Press = -328.474139225243
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.845   -13839.845   -13996.818   -13996.818    303.67417    303.67417    47969.938    47969.938    163.71553    163.71553 
    6000   -13832.257   -13832.257   -13998.425   -13998.425    321.46282    321.46282    47949.822    47949.822    792.22421    792.22421 
Loop time of 304.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.650 hours/ns, 3.281 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.61     | 303.61     | 303.61     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16664    | 0.16664    | 0.16664    |   0.0 |  0.05
Output  | 0.0001794  | 0.0001794  | 0.0001794  |   0.0 |  0.00
Modify  | 0.85271    | 0.85271    | 0.85271    |   0.0 |  0.28
Other   |            | 0.1094     |            |       |  0.04

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:      343582.0 ave      343582 max      343582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343582
Ave neighs/atom = 85.895500
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 = 312.4880815808, Press = -5.77665171603663
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13832.257   -13832.257   -13998.425   -13998.425    321.46282    321.46282    47949.822    47949.822    792.22421    792.22421 
    7000   -13839.916   -13839.916   -13998.644   -13998.644    307.07113    307.07113    47990.871    47990.871    -555.1045    -555.1045 
Loop time of 276.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.312 ns/day, 76.891 hours/ns, 3.613 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 275.84     | 275.84     | 275.84     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15166    | 0.15166    | 0.15166    |   0.0 |  0.05
Output  | 0.0001795  | 0.0001795  | 0.0001795  |   0.0 |  0.00
Modify  | 0.72057    | 0.72057    | 0.72057    |   0.0 |  0.26
Other   |            | 0.09895    |            |       |  0.04

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:      343694.0 ave      343694 max      343694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343694
Ave neighs/atom = 85.923500
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 = 312.919461733635, Press = 6.33444623418757
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.916   -13839.916   -13998.644   -13998.644    307.07113    307.07113    47990.871    47990.871    -555.1045    -555.1045 
    8000   -13838.151   -13838.151   -13998.326   -13998.326    309.87024    309.87024    48025.588    48025.588   -1624.4261   -1624.4261 
Loop time of 297.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.291 ns/day, 82.518 hours/ns, 3.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 295.98     | 295.98     | 295.98     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16126    | 0.16126    | 0.16126    |   0.0 |  0.05
Output  | 0.0002419  | 0.0002419  | 0.0002419  |   0.0 |  0.00
Modify  | 0.81431    | 0.81431    | 0.81431    |   0.0 |  0.27
Other   |            | 0.1062     |            |       |  0.04

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:      343474.0 ave      343474 max      343474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343474
Ave neighs/atom = 85.868500
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.081594639639, Press = -29.1114050884673
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13838.151   -13838.151   -13998.326   -13998.326    309.87024    309.87024    48025.588    48025.588   -1624.4261   -1624.4261 
    9000   -13831.938   -13831.938   -13994.099   -13994.099    313.71148    313.71148    47901.848    47901.848    2548.8758    2548.8758 
Loop time of 299.191 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.289 ns/day, 83.109 hours/ns, 3.342 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    | 298.1      | 298.1      | 298.1      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16218    | 0.16218    | 0.16218    |   0.0 |  0.05
Output  | 0.00017738 | 0.00017738 | 0.00017738 |   0.0 |  0.00
Modify  | 0.81889    | 0.81889    | 0.81889    |   0.0 |  0.27
Other   |            | 0.1066     |            |       |  0.04

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:      343508.0 ave      343508 max      343508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343508
Ave neighs/atom = 85.877000
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.44585584741, Press = -2.21842525321
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13831.938   -13831.938   -13994.099   -13994.099    313.71148    313.71148    47901.848    47901.848    2548.8758    2548.8758 
   10000   -13838.576   -13838.576   -13999.095   -13999.095    310.53422    310.53422    47969.812    47969.812   -35.985295   -35.985295 
Loop time of 303.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.341 hours/ns, 3.294 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 302.5      | 302.5      | 302.5      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16662    | 0.16662    | 0.16662    |   0.0 |  0.05
Output  | 0.00024613 | 0.00024613 | 0.00024613 |   0.0 |  0.00
Modify  | 0.85032    | 0.85032    | 0.85032    |   0.0 |  0.28
Other   |            | 0.1094     |            |       |  0.04

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:      343698.0 ave      343698 max      343698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343698
Ave neighs/atom = 85.924500
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.656549760928, Press = 1.43524965404908
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13838.576   -13838.576   -13999.095   -13999.095    310.53422    310.53422    47969.812    47969.812   -35.985295   -35.985295 
   11000   -13834.684   -13834.684   -13995.175   -13995.175    310.48067    310.48067    48005.273    48005.273   -661.77824   -661.77824 
Loop time of 302.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.286 ns/day, 83.921 hours/ns, 3.310 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    | 301.01     | 301.01     | 301.01     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16589    | 0.16589    | 0.16589    |   0.0 |  0.05
Output  | 0.00023048 | 0.00023048 | 0.00023048 |   0.0 |  0.00
Modify  | 0.83232    | 0.83232    | 0.83232    |   0.0 |  0.28
Other   |            | 0.1089     |            |       |  0.04

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:      343610.0 ave      343610 max      343610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343610
Ave neighs/atom = 85.902500
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.70344804565, Press = -4.6723666737385
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13834.684   -13834.684   -13995.175   -13995.175    310.48067    310.48067    48005.273    48005.273   -661.77824   -661.77824 
   12000   -13835.881   -13835.881   -13996.984   -13996.984    311.66348    311.66348    47956.406    47956.406    522.53012    522.53012 
Loop time of 304.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.671 hours/ns, 3.281 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.71     | 303.71     | 303.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16488    | 0.16488    | 0.16488    |   0.0 |  0.05
Output  | 0.00023012 | 0.00023012 | 0.00023012 |   0.0 |  0.00
Modify  | 0.83223    | 0.83223    | 0.83223    |   0.0 |  0.27
Other   |            | 0.1097     |            |       |  0.04

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:      343488.0 ave      343488 max      343488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343488
Ave neighs/atom = 85.872000
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.38254632565, Press = -4.9923025919067
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.881   -13835.881   -13996.984   -13996.984    311.66348    311.66348    47956.406    47956.406    522.53012    522.53012 
   13000   -13837.725   -13837.725   -13999.182   -13999.182     312.3502     312.3502    47966.989    47966.989    33.883412    33.883412 
Loop time of 267.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.323 ns/day, 74.200 hours/ns, 3.744 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.19     | 266.19     | 266.19     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14877    | 0.14877    | 0.14877    |   0.0 |  0.06
Output  | 0.00017779 | 0.00017779 | 0.00017779 |   0.0 |  0.00
Modify  | 0.68639    | 0.68639    | 0.68639    |   0.0 |  0.26
Other   |            | 0.09694    |            |       |  0.04

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:      343580.0 ave      343580 max      343580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343580
Ave neighs/atom = 85.895000
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.375024169793, Press = 1.05311775245933
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13837.725   -13837.725   -13999.182   -13999.182     312.3502     312.3502    47966.989    47966.989    33.883412    33.883412 
   14000   -13835.232   -13835.232    -13995.33    -13995.33    309.71955    309.71955    48021.591    48021.591   -1005.0142   -1005.0142 
Loop time of 277.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.311 ns/day, 77.121 hours/ns, 3.602 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 276.64     | 276.64     | 276.64     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1541     | 0.1541     | 0.1541     |   0.0 |  0.06
Output  | 0.00017954 | 0.00017954 | 0.00017954 |   0.0 |  0.00
Modify  | 0.74444    | 0.74444    | 0.74444    |   0.0 |  0.27
Other   |            | 0.101      |            |       |  0.04

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:      343632.0 ave      343632 max      343632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343632
Ave neighs/atom = 85.908000
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.498066700959, Press = -4.34659680374216
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.232   -13835.232    -13995.33    -13995.33    309.71955    309.71955    48021.591    48021.591   -1005.0142   -1005.0142 
   15000   -13833.781   -13833.781   -13994.136   -13994.136    310.21715    310.21715     47931.87     47931.87    1709.9427    1709.9427 
Loop time of 305.796 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.943 hours/ns, 3.270 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.68     | 304.68     | 304.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16502    | 0.16502    | 0.16502    |   0.0 |  0.05
Output  | 0.00056564 | 0.00056564 | 0.00056564 |   0.0 |  0.00
Modify  | 0.83889    | 0.83889    | 0.83889    |   0.0 |  0.27
Other   |            | 0.1082     |            |       |  0.04

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:      343500.0 ave      343500 max      343500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343500
Ave neighs/atom = 85.875000
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.710836114954, Press = -5.74958772165424
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13833.781   -13833.781   -13994.136   -13994.136    310.21715    310.21715     47931.87     47931.87    1709.9427    1709.9427 
   16000   -13833.339   -13833.339   -13995.928   -13995.928    314.54001    314.54001    47968.869    47968.869    485.76699    485.76699 
Loop time of 285.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.303 ns/day, 79.285 hours/ns, 3.504 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    | 284.41     | 284.41     | 284.41     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15748    | 0.15748    | 0.15748    |   0.0 |  0.06
Output  | 0.0002511  | 0.0002511  | 0.0002511  |   0.0 |  0.00
Modify  | 0.75983    | 0.75983    | 0.75983    |   0.0 |  0.27
Other   |            | 0.1028     |            |       |  0.04

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:      343670.0 ave      343670 max      343670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343670
Ave neighs/atom = 85.917500
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.679398894469, Press = 3.09779217854636
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13833.339   -13833.339   -13995.928   -13995.928    314.54001    314.54001    47968.869    47968.869    485.76699    485.76699 
   17000   -13839.371   -13839.371   -13998.842   -13998.842    308.50877    308.50877     48011.51     48011.51   -1220.3675   -1220.3675 
Loop time of 305.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.861 hours/ns, 3.273 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.4      | 304.4      | 304.4      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16432    | 0.16432    | 0.16432    |   0.0 |  0.05
Output  | 0.00022595 | 0.00022595 | 0.00022595 |   0.0 |  0.00
Modify  | 0.82902    | 0.82902    | 0.82902    |   0.0 |  0.27
Other   |            | 0.1083     |            |       |  0.04

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:      343678.0 ave      343678 max      343678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343678
Ave neighs/atom = 85.919500
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.702150858309, Press = -3.04276902163258
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.371   -13839.371   -13998.842   -13998.842    308.50877    308.50877     48011.51     48011.51   -1220.3675   -1220.3675 
   18000   -13833.543   -13833.543   -13999.236   -13999.236    320.54494    320.54494    47967.755    47967.755    111.41789    111.41789 
Loop time of 282.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.404 hours/ns, 3.543 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    | 281.26     | 281.26     | 281.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1529     | 0.1529     | 0.1529     |   0.0 |  0.05
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.73528    | 0.73528    | 0.73528    |   0.0 |  0.26
Other   |            | 0.1028     |            |       |  0.04

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:      343518.0 ave      343518 max      343518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343518
Ave neighs/atom = 85.879500
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.797537291839, Press = -2.56820278091837
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13833.543   -13833.543   -13999.236   -13999.236    320.54494    320.54494    47967.755    47967.755    111.41789    111.41789 
   19000   -13837.551   -13837.551   -14000.476   -14000.476    315.18969    315.18969    47957.488    47957.488    228.85494    228.85494 
Loop time of 286.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.302 ns/day, 79.491 hours/ns, 3.494 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    | 285.15     | 285.15     | 285.15     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15649    | 0.15649    | 0.15649    |   0.0 |  0.05
Output  | 0.00023247 | 0.00023247 | 0.00023247 |   0.0 |  0.00
Modify  | 0.76112    | 0.76112    | 0.76112    |   0.0 |  0.27
Other   |            | 0.1027     |            |       |  0.04

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:      343546.0 ave      343546 max      343546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343546
Ave neighs/atom = 85.886500
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.869739833089, Press = -0.305610011531164
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13837.551   -13837.551   -14000.476   -14000.476    315.18969    315.18969    47957.488    47957.488    228.85494    228.85494 
   20000   -13833.821   -13833.821   -13997.736   -13997.736    317.10287    317.10287    47991.279    47991.279   -419.75049   -419.75049 
Loop time of 298.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.877 hours/ns, 3.352 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    | 297.27     | 297.27     | 297.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16209    | 0.16209    | 0.16209    |   0.0 |  0.05
Output  | 0.00018016 | 0.00018016 | 0.00018016 |   0.0 |  0.00
Modify  | 0.81843    | 0.81843    | 0.81843    |   0.0 |  0.27
Other   |            | 0.1071     |            |       |  0.04

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:      343582.0 ave      343582 max      343582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343582
Ave neighs/atom = 85.895500
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.859503560064, Press = -0.757711090397177
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13833.821   -13833.821   -13997.736   -13997.736    317.10287    317.10287    47991.279    47991.279   -419.75049   -419.75049 
   21000   -13837.622   -13837.622   -13996.404   -13996.404    307.17419    307.17419     48000.67     48000.67   -588.91669   -588.91669 
Loop time of 304.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.605 hours/ns, 3.283 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    | 303.46     | 303.46     | 303.46     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16699    | 0.16699    | 0.16699    |   0.0 |  0.05
Output  | 0.00018319 | 0.00018319 | 0.00018319 |   0.0 |  0.00
Modify  | 0.84064    | 0.84064    | 0.84064    |   0.0 |  0.28
Other   |            | 0.108      |            |       |  0.04

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:      343598.0 ave      343598 max      343598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343598
Ave neighs/atom = 85.899500
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.686427915218, Press = -2.31157097957992
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13837.622   -13837.622   -13996.404   -13996.404    307.17419    307.17419     48000.67     48000.67   -588.91669   -588.91669 
   22000   -13836.278   -13836.278   -14002.194   -14002.194    320.97516    320.97516    47918.438    47918.438    1289.6323    1289.6323 
Loop time of 283.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 78.888 hours/ns, 3.521 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    | 282.99     | 282.99     | 282.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15402    | 0.15402    | 0.15402    |   0.0 |  0.05
Output  | 0.00017726 | 0.00017726 | 0.00017726 |   0.0 |  0.00
Modify  | 0.75031    | 0.75031    | 0.75031    |   0.0 |  0.26
Other   |            | 0.1037     |            |       |  0.04

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:      343482.0 ave      343482 max      343482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343482
Ave neighs/atom = 85.870500
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.648754279141, Press = -2.72747584034175
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13836.278   -13836.278   -14002.194   -14002.194    320.97516    320.97516    47918.438    47918.438    1289.6323    1289.6323 
   23000    -13832.77    -13832.77   -13996.671   -13996.671    317.07833    317.07833    47976.072    47976.072    166.98381    166.98381 
Loop time of 260.158 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.266 hours/ns, 3.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.26     | 259.26     | 259.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14363    | 0.14363    | 0.14363    |   0.0 |  0.06
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.65911    | 0.65911    | 0.65911    |   0.0 |  0.25
Other   |            | 0.09681    |            |       |  0.04

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:      343638.0 ave      343638 max      343638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343638
Ave neighs/atom = 85.909500
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.614481212667, Press = 2.42365860686258
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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    -13832.77    -13832.77   -13996.671   -13996.671    317.07833    317.07833    47976.072    47976.072    166.98381    166.98381 
   24000   -13835.693   -13835.693   -13997.705   -13997.705    313.42472    313.42472     48014.37     48014.37   -1114.9966   -1114.9966 
Loop time of 286.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.301 ns/day, 79.670 hours/ns, 3.487 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    | 285.8      | 285.8      | 285.8      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.05
Output  | 0.00022482 | 0.00022482 | 0.00022482 |   0.0 |  0.00
Modify  | 0.75497    | 0.75497    | 0.75497    |   0.0 |  0.26
Other   |            | 0.1041     |            |       |  0.04

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:      343524.0 ave      343524 max      343524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343524
Ave neighs/atom = 85.881000
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.634456767112, Press = -2.34120973909099
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.693   -13835.693   -13997.705   -13997.705    313.42472    313.42472     48014.37     48014.37   -1114.9966   -1114.9966 
   25000   -13836.713   -13836.713   -13996.725   -13996.725    309.55377    309.55377    47956.031    47956.031    468.75116    468.75116 
Loop time of 304.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.544 hours/ns, 3.286 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.24     | 303.24     | 303.24     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16553    | 0.16553    | 0.16553    |   0.0 |  0.05
Output  | 0.00027497 | 0.00027497 | 0.00027497 |   0.0 |  0.00
Modify  | 0.83813    | 0.83813    | 0.83813    |   0.0 |  0.28
Other   |            | 0.1089     |            |       |  0.04

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:      343460.0 ave      343460 max      343460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343460
Ave neighs/atom = 85.865000
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.605880641682, Press = -1.93885831644454
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13836.713   -13836.713   -13996.725   -13996.725    309.55377    309.55377    47956.031    47956.031    468.75116    468.75116 
   26000   -13834.656   -13834.656   -13995.714   -13995.714    311.57697    311.57697    47956.539    47956.539    717.04539    717.04539 
Loop time of 304.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.696 hours/ns, 3.280 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 303.79     | 303.79     | 303.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16557    | 0.16557    | 0.16557    |   0.0 |  0.05
Output  | 0.00017877 | 0.00017877 | 0.00017877 |   0.0 |  0.00
Modify  | 0.83722    | 0.83722    | 0.83722    |   0.0 |  0.27
Other   |            | 0.1091     |            |       |  0.04

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:      343752.0 ave      343752 max      343752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343752
Ave neighs/atom = 85.938000
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.674643768654, Press = 0.00513624427788114
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13834.656   -13834.656   -13995.714   -13995.714    311.57697    311.57697    47956.539    47956.539    717.04539    717.04539 
   27000    -13834.24    -13834.24    -13997.33    -13997.33    315.50955    315.50955    48001.854    48001.854   -740.67599   -740.67599 
Loop time of 304.995 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.721 hours/ns, 3.279 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    | 303.88     | 303.88     | 303.88     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16504    | 0.16504    | 0.16504    |   0.0 |  0.05
Output  | 0.00017936 | 0.00017936 | 0.00017936 |   0.0 |  0.00
Modify  | 0.83946    | 0.83946    | 0.83946    |   0.0 |  0.28
Other   |            | 0.1099     |            |       |  0.04

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:      343648.0 ave      343648 max      343648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343648
Ave neighs/atom = 85.912000
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.620519433739, Press = -1.55403773988383
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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    -13834.24    -13834.24    -13997.33    -13997.33    315.50955    315.50955    48001.854    48001.854   -740.67599   -740.67599 
   28000   -13841.104   -13841.104   -14003.181   -14003.181     313.5473     313.5473    47926.815    47926.815    782.43181    782.43181 
Loop time of 305.689 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.914 hours/ns, 3.271 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.57     | 304.57     | 304.57     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16678    | 0.16678    | 0.16678    |   0.0 |  0.05
Output  | 0.00017892 | 0.00017892 | 0.00017892 |   0.0 |  0.00
Modify  | 0.84774    | 0.84774    | 0.84774    |   0.0 |  0.28
Other   |            | 0.109      |            |       |  0.04

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:      343542.0 ave      343542 max      343542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343542
Ave neighs/atom = 85.885500
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.530300307488, Press = -2.14925723425864
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13841.104   -13841.104   -14003.181   -14003.181     313.5473     313.5473    47926.815    47926.815    782.43181    782.43181 
   29000   -13833.989   -13833.989   -13999.223   -13999.223     319.6573     319.6573    47960.373    47960.373    397.84406    397.84406 
Loop time of 267.446 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.323 ns/day, 74.290 hours/ns, 3.739 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.51     | 266.51     | 266.51     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14737    | 0.14737    | 0.14737    |   0.0 |  0.06
Output  | 0.00017707 | 0.00017707 | 0.00017707 |   0.0 |  0.00
Modify  | 0.68738    | 0.68738    | 0.68738    |   0.0 |  0.26
Other   |            | 0.09781    |            |       |  0.04

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:      343698.0 ave      343698 max      343698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343698
Ave neighs/atom = 85.924500
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.470334789568, Press = 2.07217887714363
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13833.989   -13833.989   -13999.223   -13999.223     319.6573     319.6573    47960.373    47960.373    397.84406    397.84406 
   30000   -13839.982   -13839.982   -14002.268   -14002.268    313.95375    313.95375    48019.402    48019.402    -1743.076    -1743.076 
Loop time of 259.942 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.206 hours/ns, 3.847 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.04     | 259.04     | 259.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14352    | 0.14352    | 0.14352    |   0.0 |  0.06
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.65767    | 0.65767    | 0.65767    |   0.0 |  0.25
Other   |            | 0.09837    |            |       |  0.04

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:      343556.0 ave      343556 max      343556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343556
Ave neighs/atom = 85.889000
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.386026682423, Press = -1.28762987894093
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.982   -13839.982   -14002.268   -14002.268    313.95375    313.95375    48019.402    48019.402    -1743.076    -1743.076 
   31000   -13832.037   -13832.037   -13996.867   -13996.867    318.87482    318.87482    47944.835    47944.835    1053.9866    1053.9866 
Loop time of 281.196 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.110 hours/ns, 3.556 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    | 280.22     | 280.22     | 280.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14922    | 0.14922    | 0.14922    |   0.0 |  0.05
Output  | 0.00017627 | 0.00017627 | 0.00017627 |   0.0 |  0.00
Modify  | 0.72552    | 0.72552    | 0.72552    |   0.0 |  0.26
Other   |            | 0.1011     |            |       |  0.04

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:      343616.0 ave      343616 max      343616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343616
Ave neighs/atom = 85.904000
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.37974460633, Press = -1.18472273044153
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13832.037   -13832.037   -13996.867   -13996.867    318.87482    318.87482    47944.835    47944.835    1053.9866    1053.9866 
   32000   -13838.709   -13838.709   -13998.609   -13998.609    309.33898    309.33898    47959.858    47959.858    293.57989    293.57989 
Loop time of 264.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.601 hours/ns, 3.774 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 264.05     | 264.05     | 264.05     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14427    | 0.14427    | 0.14427    |   0.0 |  0.05
Output  | 0.00017837 | 0.00017837 | 0.00017837 |   0.0 |  0.00
Modify  | 0.67202    | 0.67202    | 0.67202    |   0.0 |  0.25
Other   |            | 0.09922    |            |       |  0.04

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:      343714.0 ave      343714 max      343714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343714
Ave neighs/atom = 85.928500
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.454801964344, Press = -0.443582321157272
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13838.709   -13838.709   -13998.609   -13998.609    309.33898    309.33898    47959.858    47959.858    293.57989    293.57989 
   33000   -13835.479   -13835.479   -13998.898   -13998.898    316.14524    316.14524    47990.844    47990.844   -682.09102   -682.09102 
Loop time of 278.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.310 ns/day, 77.401 hours/ns, 3.589 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 277.65     | 277.65     | 277.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15269    | 0.15269    | 0.15269    |   0.0 |  0.05
Output  | 0.00022164 | 0.00022164 | 0.00022164 |   0.0 |  0.00
Modify  | 0.73496    | 0.73496    | 0.73496    |   0.0 |  0.26
Other   |            | 0.1002     |            |       |  0.04

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:      343638.0 ave      343638 max      343638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343638
Ave neighs/atom = 85.909500
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.437757233328, Press = -0.850723000984066
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.479   -13835.479   -13998.898   -13998.898    316.14524    316.14524    47990.844    47990.844   -682.09102   -682.09102 
   34000   -13837.803   -13837.803   -13996.921   -13996.921    307.82544    307.82544    47954.662    47954.662     653.4859     653.4859 
Loop time of 283.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.305 ns/day, 78.777 hours/ns, 3.526 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    | 282.59     | 282.59     | 282.59     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15457    | 0.15457    | 0.15457    |   0.0 |  0.05
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.74985    | 0.74985    | 0.74985    |   0.0 |  0.26
Other   |            | 0.102      |            |       |  0.04

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:      343614.0 ave      343614 max      343614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343614
Ave neighs/atom = 85.903500
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.410846322682, Press = -0.999747956649008
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13837.803   -13837.803   -13996.921   -13996.921    307.82544    307.82544    47954.662    47954.662     653.4859     653.4859 
   35000   -13835.211   -13835.211   -13997.369   -13997.369    313.70585    313.70585    47999.955    47999.955   -569.34369   -569.34369 
Loop time of 300.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.572 hours/ns, 3.324 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 299.79     | 299.79     | 299.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16133    | 0.16133    | 0.16133    |   0.0 |  0.05
Output  | 0.00017935 | 0.00017935 | 0.00017935 |   0.0 |  0.00
Modify  | 0.80192    | 0.80192    | 0.80192    |   0.0 |  0.27
Other   |            | 0.1051     |            |       |  0.03

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:      343578.0 ave      343578 max      343578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343578
Ave neighs/atom = 85.894500
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.359194526038, Press = -0.655983880572174
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.211   -13835.211   -13997.369   -13997.369    313.70585    313.70585    47999.955    47999.955   -569.34369   -569.34369 
   36000   -13838.349   -13838.349   -13999.094   -13999.094    310.97107    310.97107    47962.858    47962.858    215.27514    215.27514 
Loop time of 296.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.291 ns/day, 82.495 hours/ns, 3.367 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 295.92     | 295.92     | 295.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16076    | 0.16076    | 0.16076    |   0.0 |  0.05
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.79559    | 0.79559    | 0.79559    |   0.0 |  0.27
Other   |            | 0.1045     |            |       |  0.04

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:      343584.0 ave      343584 max      343584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343584
Ave neighs/atom = 85.896000
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.284218815154, Press = -1.42905130579132
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13838.349   -13838.349   -13999.094   -13999.094    310.97107    310.97107    47962.858    47962.858    215.27514    215.27514 
   37000   -13838.707   -13838.707    -13998.86    -13998.86    309.82711    309.82711    47899.958    47899.958    1990.6504    1990.6504 
Loop time of 260.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.498 hours/ns, 3.832 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.09     | 260.09     | 260.09     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14626    | 0.14626    | 0.14626    |   0.0 |  0.06
Output  | 0.00017947 | 0.00017947 | 0.00017947 |   0.0 |  0.00
Modify  | 0.65959    | 0.65959    | 0.65959    |   0.0 |  0.25
Other   |            | 0.09675    |            |       |  0.04

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:      343574.0 ave      343574 max      343574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343574
Ave neighs/atom = 85.893500
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.283901010036, Press = 1.14975695028306
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13838.707   -13838.707    -13998.86    -13998.86    309.82711    309.82711    47899.958    47899.958    1990.6504    1990.6504 
   38000   -13835.976   -13835.976   -13996.213   -13996.213    309.99024    309.99024    48066.803    48066.803   -2522.0946   -2522.0946 
Loop time of 263.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.214 hours/ns, 3.794 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 262.66     | 262.66     | 262.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14673    | 0.14673    | 0.14673    |   0.0 |  0.06
Output  | 0.00024819 | 0.00024819 | 0.00024819 |   0.0 |  0.00
Modify  | 0.67248    | 0.67248    | 0.67248    |   0.0 |  0.26
Other   |            | 0.09671    |            |       |  0.04

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:      343670.0 ave      343670 max      343670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343670
Ave neighs/atom = 85.917500
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.320939676558, Press = -0.332046826061638
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13835.976   -13835.976   -13996.213   -13996.213    309.99024    309.99024    48066.803    48066.803   -2522.0946   -2522.0946 
   39000   -13839.838   -13839.838   -13998.864   -13998.864    307.64568    307.64568    47952.603    47952.603    476.09662    476.09662 
Loop time of 271.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.319 ns/day, 75.324 hours/ns, 3.688 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 270.24     | 270.24     | 270.24     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14647    | 0.14647    | 0.14647    |   0.0 |  0.05
Output  | 0.00017747 | 0.00017747 | 0.00017747 |   0.0 |  0.00
Modify  | 0.67994    | 0.67994    | 0.67994    |   0.0 |  0.25
Other   |            | 0.09714    |            |       |  0.04

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:      343410.0 ave      343410 max      343410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343410
Ave neighs/atom = 85.852500
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.264035906562, Press = -1.88700306897761
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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      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   -13839.838   -13839.838   -13998.864   -13998.864    307.64568    307.64568    47952.603    47952.603    476.09662    476.09662 
   40000   -13832.537   -13832.537   -13998.857   -13998.857    321.75711    321.75711    47963.998    47963.998    335.10717    335.10717 
Loop time of 289.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.488 hours/ns, 3.451 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 288.75     | 288.75     | 288.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1555     | 0.1555     | 0.1555     |   0.0 |  0.05
Output  | 0.00017692 | 0.00017692 | 0.00017692 |   0.0 |  0.00
Modify  | 0.74848    | 0.74848    | 0.74848    |   0.0 |  0.26
Other   |            | 0.1011     |            |       |  0.03

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:      343576.0 ave      343576 max      343576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343576
Ave neighs/atom = 85.894000
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
47973.079556951

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0