# 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.917371571063995*${_u_distance}
variable latticeconst_converted equal 3.917371571063995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737157106399
Lattice spacing in x,y,z = 3.9173716 3.9173716 3.9173716
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 (39.173716 39.173716 39.173716)
  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 (39.173716 39.173716 39.173716)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongLee_2020_PtC__MO_716623333967_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 60115.200756225 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_716623333967_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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22907.791   -22907.791       -23080       -23080       333.15       333.15    60115.201    60115.201    3059.7538    3059.7538 
    1000   -22727.252   -22727.252   -22909.134   -22909.134    351.86297    351.86297      60793.1      60793.1   -3709.8379   -3709.8379 
Loop time of 218.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.652 hours/ns, 4.580 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    | 217.28     | 217.28     | 217.28     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16289    | 0.16289    | 0.16289    |   0.0 |  0.07
Output  | 0.0002213  | 0.0002213  | 0.0002213  |   0.0 |  0.00
Modify  | 0.79477    | 0.79477    | 0.79477    |   0.0 |  0.36
Other   |            | 0.1068     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -22727.252   -22727.252   -22909.134   -22909.134    351.86297    351.86297      60793.1      60793.1   -3709.8379   -3709.8379 
    2000   -22736.054   -22736.054   -22913.154   -22913.154    342.61214    342.61214    60708.229    60708.229   -525.31809   -525.31809 
Loop time of 217.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.319 hours/ns, 4.605 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    | 216.18     | 216.18     | 216.18     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15324    | 0.15324    | 0.15324    |   0.0 |  0.07
Output  | 0.00024907 | 0.00024907 | 0.00024907 |   0.0 |  0.00
Modify  | 0.71798    | 0.71798    | 0.71798    |   0.0 |  0.33
Other   |            | 0.101      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311912.0 ave      311912 max      311912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -22736.054   -22736.054   -22913.154   -22913.154    342.61214    342.61214    60708.229    60708.229   -525.31809   -525.31809 
    3000   -22738.201   -22738.201   -22913.914   -22913.914    339.92749    339.92749    60709.687    60709.687   -759.35362   -759.35362 
Loop time of 232.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.498 hours/ns, 4.307 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    | 231.12     | 231.12     | 231.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1629     | 0.1629     | 0.1629     |   0.0 |  0.07
Output  | 0.0002147  | 0.0002147  | 0.0002147  |   0.0 |  0.00
Modify  | 0.80092    | 0.80092    | 0.80092    |   0.0 |  0.34
Other   |            | 0.1063     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311962.0 ave      311962 max      311962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22738.201   -22738.201   -22913.914   -22913.914    339.92749    339.92749    60709.687    60709.687   -759.35362   -759.35362 
    4000   -22732.743   -22732.743   -22909.708   -22909.708    342.35041    342.35041    60694.946    60694.946    835.29575    835.29575 
Loop time of 203.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.503 hours/ns, 4.916 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    | 202.53     | 202.53     | 202.53     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14422    | 0.14422    | 0.14422    |   0.0 |  0.07
Output  | 0.00022077 | 0.00022077 | 0.00022077 |   0.0 |  0.00
Modify  | 0.64228    | 0.64228    | 0.64228    |   0.0 |  0.32
Other   |            | 0.09474    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311934.0 ave      311934 max      311934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311934
Ave neighs/atom = 77.983500
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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -22732.743   -22732.743   -22909.708   -22909.708    342.35041    342.35041    60694.946    60694.946    835.29575    835.29575 
    5000   -22738.273   -22738.273   -22906.813   -22906.813    326.05207    326.05207    60703.787    60703.787    378.62368    378.62368 
Loop time of 203.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.513 hours/ns, 4.915 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    | 202.57     | 202.57     | 202.57     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14395    | 0.14395    | 0.14395    |   0.0 |  0.07
Output  | 0.0001783  | 0.0001783  | 0.0001783  |   0.0 |  0.00
Modify  | 0.64375    | 0.64375    | 0.64375    |   0.0 |  0.32
Other   |            | 0.09401    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311956.0 ave      311956 max      311956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311956
Ave neighs/atom = 77.989000
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 = 335.649616670263, Press = 323.638300494826
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -22738.273   -22738.273   -22906.813   -22906.813    326.05207    326.05207    60703.787    60703.787    378.62368    378.62368 
    6000   -22737.637   -22737.637    -22911.02    -22911.02    335.41966    335.41966    60683.166    60683.166    957.09295    957.09295 
Loop time of 237.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.905 hours/ns, 4.215 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 236.14     | 236.14     | 236.14     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16628    | 0.16628    | 0.16628    |   0.0 |  0.07
Output  | 0.00023764 | 0.00023764 | 0.00023764 |   0.0 |  0.00
Modify  | 0.84382    | 0.84382    | 0.84382    |   0.0 |  0.36
Other   |            | 0.1077     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311908.0 ave      311908 max      311908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
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 = 333.59516624329, Press = -13.4421004632602
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22737.637   -22737.637    -22911.02    -22911.02    335.41966    335.41966    60683.166    60683.166    957.09295    957.09295 
    7000   -22733.996   -22733.996    -22907.92    -22907.92    336.46831    336.46831    60721.483    60721.483   -450.13255   -450.13255 
Loop time of 220.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.192 hours/ns, 4.539 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    | 219.29     | 219.29     | 219.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15495    | 0.15495    | 0.15495    |   0.0 |  0.07
Output  | 0.00018192 | 0.00018192 | 0.00018192 |   0.0 |  0.00
Modify  | 0.7466     | 0.7466     | 0.7466     |   0.0 |  0.34
Other   |            | 0.1009     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
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 = 332.972777961037, Press = 0.691534121217688
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -22733.996   -22733.996    -22907.92    -22907.92    336.46831    336.46831    60721.483    60721.483   -450.13255   -450.13255 
    8000   -22738.779   -22738.779   -22910.184   -22910.184    331.59347    331.59347    60701.369    60701.369    246.57794    246.57794 
Loop time of 203.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.420 hours/ns, 4.923 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    | 202.21     | 202.21     | 202.21     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14418    | 0.14418    | 0.14418    |   0.0 |  0.07
Output  | 0.00018152 | 0.00018152 | 0.00018152 |   0.0 |  0.00
Modify  | 0.66469    | 0.66469    | 0.66469    |   0.0 |  0.33
Other   |            | 0.09433    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311888.0 ave      311888 max      311888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311888
Ave neighs/atom = 77.972000
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 = 333.230956101571, Press = -15.1089984438236
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22738.779   -22738.779   -22910.184   -22910.184    331.59347    331.59347    60701.369    60701.369    246.57794    246.57794 
    9000   -22732.156   -22732.156   -22908.229   -22908.229     340.6235     340.6235    60665.572    60665.572    2131.3417    2131.3417 
Loop time of 203.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.511 hours/ns, 4.915 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    | 202.54     | 202.54     | 202.54     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14424    | 0.14424    | 0.14424    |   0.0 |  0.07
Output  | 0.00022059 | 0.00022059 | 0.00022059 |   0.0 |  0.00
Modify  | 0.66449    | 0.66449    | 0.66449    |   0.0 |  0.33
Other   |            | 0.09414    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311938.0 ave      311938 max      311938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311938
Ave neighs/atom = 77.984500
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 = 333.421333260867, Press = 5.19290645209275
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22732.156   -22732.156   -22908.229   -22908.229     340.6235     340.6235    60665.572    60665.572    2131.3417    2131.3417 
   10000   -22738.882   -22738.882   -22909.913   -22909.913    330.87121    330.87121    60748.361    60748.361   -1982.6347   -1982.6347 
Loop time of 210.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.387 hours/ns, 4.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 209.24     | 209.24     | 209.24     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14994    | 0.14994    | 0.14994    |   0.0 |  0.07
Output  | 0.00022006 | 0.00022006 | 0.00022006 |   0.0 |  0.00
Modify  | 0.70246    | 0.70246    | 0.70246    |   0.0 |  0.33
Other   |            | 0.09696    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311914.0 ave      311914 max      311914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311914
Ave neighs/atom = 77.978500
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 = 333.762933668473, Press = -4.45655520595166
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22738.882   -22738.882   -22909.913   -22909.913    330.87121    330.87121    60748.361    60748.361   -1982.6347   -1982.6347 
   11000   -22732.409   -22732.409   -22906.031   -22906.031    335.88499    335.88499    60700.943    60700.943    836.73655    836.73655 
Loop time of 236.238 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.622 hours/ns, 4.233 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    | 235.12     | 235.12     | 235.12     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16424    | 0.16424    | 0.16424    |   0.0 |  0.07
Output  | 0.00021963 | 0.00021963 | 0.00021963 |   0.0 |  0.00
Modify  | 0.84054    | 0.84054    | 0.84054    |   0.0 |  0.36
Other   |            | 0.1096     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311940.0 ave      311940 max      311940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311940
Ave neighs/atom = 77.985000
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 = 333.640700474169, Press = -11.2866807955242
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22732.409   -22732.409   -22906.031   -22906.031    335.88499    335.88499    60700.943    60700.943    836.73655    836.73655 
   12000   -22738.943   -22738.943   -22911.471   -22911.471    333.76742    333.76742    60711.355    60711.355   -379.70743   -379.70743 
Loop time of 235.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.473 hours/ns, 4.243 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    | 234.57     | 234.57     | 234.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16635    | 0.16635    | 0.16635    |   0.0 |  0.07
Output  | 0.00018073 | 0.00018073 | 0.00018073 |   0.0 |  0.00
Modify  | 0.85615    | 0.85615    | 0.85615    |   0.0 |  0.36
Other   |            | 0.1098     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311924.0 ave      311924 max      311924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311924
Ave neighs/atom = 77.981000
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 = 333.658770101127, Press = 4.76174799632594
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22738.943   -22738.943   -22911.471   -22911.471    333.76742    333.76742    60711.355    60711.355   -379.70743   -379.70743 
   13000   -22732.354   -22732.354   -22906.997   -22906.997    337.85778    337.85778    60758.574    60758.574   -1946.8147   -1946.8147 
Loop time of 235.526 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.424 hours/ns, 4.246 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    | 234.39     | 234.39     | 234.39     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16634    | 0.16634    | 0.16634    |   0.0 |  0.07
Output  | 0.00030129 | 0.00030129 | 0.00030129 |   0.0 |  0.00
Modify  | 0.85917    | 0.85917    | 0.85917    |   0.0 |  0.36
Other   |            | 0.1096     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311926.0 ave      311926 max      311926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311926
Ave neighs/atom = 77.981500
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 = 333.78175166493, Press = -1.52157098491679
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -22732.354   -22732.354   -22906.997   -22906.997    337.85778    337.85778    60758.574    60758.574   -1946.8147   -1946.8147 
   14000   -22737.147   -22737.147   -22909.552   -22909.552    333.52961    333.52961    60678.358    60678.358    1272.2623    1272.2623 
Loop time of 235.547 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.430 hours/ns, 4.245 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    | 234.42     | 234.42     | 234.42     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16621    | 0.16621    | 0.16621    |   0.0 |  0.07
Output  | 0.00018307 | 0.00018307 | 0.00018307 |   0.0 |  0.00
Modify  | 0.85077    | 0.85077    | 0.85077    |   0.0 |  0.36
Other   |            | 0.1092     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311908.0 ave      311908 max      311908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
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 = 333.94834674615, Press = -2.60293831849295
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22737.147   -22737.147   -22909.552   -22909.552    333.52961    333.52961    60678.358    60678.358    1272.2623    1272.2623 
   15000   -22739.541   -22739.541   -22909.466   -22909.466    328.73149    328.73149    60728.493    60728.493   -1006.2089   -1006.2089 
Loop time of 235.174 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.326 hours/ns, 4.252 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    | 234.06     | 234.06     | 234.06     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16277    | 0.16277    | 0.16277    |   0.0 |  0.07
Output  | 0.00049094 | 0.00049094 | 0.00049094 |   0.0 |  0.00
Modify  | 0.84104    | 0.84104    | 0.84104    |   0.0 |  0.36
Other   |            | 0.1084     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.887197655815, Press = 2.59185710392513
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22739.541   -22739.541   -22909.466   -22909.466    328.73149    328.73149    60728.493    60728.493   -1006.2089   -1006.2089 
   16000   -22741.585   -22741.585   -22910.673   -22910.673    327.11221    327.11221    60723.951    60723.951   -1003.5883   -1003.5883 
Loop time of 230.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.944 hours/ns, 4.344 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    | 229.13     | 229.13     | 229.13     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16011    | 0.16011    | 0.16011    |   0.0 |  0.07
Output  | 0.00017937 | 0.00017937 | 0.00017937 |   0.0 |  0.00
Modify  | 0.80214    | 0.80214    | 0.80214    |   0.0 |  0.35
Other   |            | 0.1057     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311954.0 ave      311954 max      311954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
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 = 333.818471640936, Press = -4.70354025410769
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22741.585   -22741.585   -22910.673   -22910.673    327.11221    327.11221    60723.951    60723.951   -1003.5883   -1003.5883 
   17000   -22735.922   -22735.922   -22907.249   -22907.249    331.44428    331.44428    60685.124    60685.124    1373.3014    1373.3014 
Loop time of 230.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 64.055 hours/ns, 4.337 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    | 229.52     | 229.52     | 229.52     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16083    | 0.16083    | 0.16083    |   0.0 |  0.07
Output  | 0.00023183 | 0.00023183 | 0.00023183 |   0.0 |  0.00
Modify  | 0.80628    | 0.80628    | 0.80628    |   0.0 |  0.35
Other   |            | 0.1069     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.596788424228, Press = -0.0744789218994742
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22735.922   -22735.922   -22907.249   -22907.249    331.44428    331.44428    60685.124    60685.124    1373.3014    1373.3014 
   18000   -22738.671   -22738.671   -22909.626   -22909.626    330.72472    330.72472    60689.074    60689.074    888.66784    888.66784 
Loop time of 236.265 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.629 hours/ns, 4.233 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    | 235.13     | 235.13     | 235.13     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16741    | 0.16741    | 0.16741    |   0.0 |  0.07
Output  | 0.00028523 | 0.00028523 | 0.00028523 |   0.0 |  0.00
Modify  | 0.86131    | 0.86131    | 0.86131    |   0.0 |  0.36
Other   |            | 0.1101     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311926.0 ave      311926 max      311926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311926
Ave neighs/atom = 77.981500
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 = 333.482206902235, Press = 0.596407845226903
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22738.671   -22738.671   -22909.626   -22909.626    330.72472    330.72472    60689.074    60689.074    888.66784    888.66784 
   19000   -22737.681   -22737.681   -22910.812   -22910.812    334.93346    334.93346    60757.433    60757.433   -2412.1218   -2412.1218 
Loop time of 229.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.376 ns/day, 63.752 hours/ns, 4.357 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    | 228.43     | 228.43     | 228.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16075    | 0.16075    | 0.16075    |   0.0 |  0.07
Output  | 0.00017606 | 0.00017606 | 0.00017606 |   0.0 |  0.00
Modify  | 0.80954    | 0.80954    | 0.80954    |   0.0 |  0.35
Other   |            | 0.1063     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311934.0 ave      311934 max      311934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311934
Ave neighs/atom = 77.983500
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 = 333.604406019978, Press = -3.32869428979862
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -22737.681   -22737.681   -22910.812   -22910.812    334.93346    334.93346    60757.433    60757.433   -2412.1218   -2412.1218 
   20000   -22736.616   -22736.616   -22910.941   -22910.941    337.24278    337.24278    60625.467    60625.467    3790.5826    3790.5826 
Loop time of 216.885 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.246 hours/ns, 4.611 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    | 215.9      | 215.9      | 215.9      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.07
Output  | 0.00017698 | 0.00017698 | 0.00017698 |   0.0 |  0.00
Modify  | 0.73141    | 0.73141    | 0.73141    |   0.0 |  0.34
Other   |            | 0.1004     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
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 = 333.598009387839, Press = -3.06251107297031
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22736.616   -22736.616   -22910.941   -22910.941    337.24278    337.24278    60625.467    60625.467    3790.5826    3790.5826 
   21000   -22737.831   -22737.831   -22909.709   -22909.709    332.50989    332.50989    60645.345    60645.345     2956.375     2956.375 
Loop time of 205.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.204 hours/ns, 4.856 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    | 205.02     | 205.02     | 205.02     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14497    | 0.14497    | 0.14497    |   0.0 |  0.07
Output  | 0.00017911 | 0.00017911 | 0.00017911 |   0.0 |  0.00
Modify  | 0.67918    | 0.67918    | 0.67918    |   0.0 |  0.33
Other   |            | 0.09639    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311950.0 ave      311950 max      311950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311950
Ave neighs/atom = 77.987500
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 = 333.589712944592, Press = 2.94406596619238
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22737.831   -22737.831   -22909.709   -22909.709    332.50989    332.50989    60645.345    60645.345     2956.375     2956.375 
   22000   -22733.105   -22733.105   -22908.228   -22908.228    338.78789    338.78789    60720.598    60720.598   -266.12848   -266.12848 
Loop time of 223.014 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 61.948 hours/ns, 4.484 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    | 221.97     | 221.97     | 221.97     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15722    | 0.15722    | 0.15722    |   0.0 |  0.07
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.78018    | 0.78018    | 0.78018    |   0.0 |  0.35
Other   |            | 0.1032     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311932.0 ave      311932 max      311932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311932
Ave neighs/atom = 77.983000
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 = 333.65405568617, Press = 1.05137858810253
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22733.105   -22733.105   -22908.228   -22908.228    338.78789    338.78789    60720.598    60720.598   -266.12848   -266.12848 
   23000   -22739.248   -22739.248   -22911.892   -22911.892    333.99235    333.99235    60706.123    60706.123   -231.61393   -231.61393 
Loop time of 203.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.435 hours/ns, 4.922 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    | 202.26     | 202.26     | 202.26     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14452    | 0.14452    | 0.14452    |   0.0 |  0.07
Output  | 0.00018128 | 0.00018128 | 0.00018128 |   0.0 |  0.00
Modify  | 0.66684    | 0.66684    | 0.66684    |   0.0 |  0.33
Other   |            | 0.09464    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311960.0 ave      311960 max      311960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311960
Ave neighs/atom = 77.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.630128510908, Press = -0.821546468866784
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22739.248   -22739.248   -22911.892   -22911.892    333.99235    333.99235    60706.123    60706.123   -231.61393   -231.61393 
   24000   -22736.229   -22736.229   -22908.782   -22908.782     333.8161     333.8161    60735.195    60735.195   -1233.6141   -1233.6141 
Loop time of 206.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.274 hours/ns, 4.850 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    | 205.27     | 205.27     | 205.27     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14552    | 0.14552    | 0.14552    |   0.0 |  0.07
Output  | 0.00023156 | 0.00023156 | 0.00023156 |   0.0 |  0.00
Modify  | 0.68012    | 0.68012    | 0.68012    |   0.0 |  0.33
Other   |            | 0.0957     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.69725841135, Press = -2.46662541567323
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -22736.229   -22736.229   -22908.782   -22908.782     333.8161     333.8161    60735.195    60735.195   -1233.6141   -1233.6141 
   25000   -22735.902   -22735.902   -22907.442   -22907.442    331.85591    331.85591    60664.743    60664.743    2151.9421    2151.9421 
Loop time of 228.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.530 hours/ns, 4.372 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    | 227.65     | 227.65     | 227.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15994    | 0.15994    | 0.15994    |   0.0 |  0.07
Output  | 0.00018096 | 0.00018096 | 0.00018096 |   0.0 |  0.00
Modify  | 0.79716    | 0.79716    | 0.79716    |   0.0 |  0.35
Other   |            | 0.1049     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311908.0 ave      311908 max      311908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
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 = 333.673680405698, Press = -2.03491204329616
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22735.902   -22735.902   -22907.442   -22907.442    331.85591    331.85591    60664.743    60664.743    2151.9421    2151.9421 
   26000   -22736.861   -22736.861   -22909.251   -22909.251    333.49965    333.49965     60703.52     60703.52    146.90102    146.90102 
Loop time of 220.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.374 hours/ns, 4.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    | 219.94     | 219.94     | 219.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15545    | 0.15545    | 0.15545    |   0.0 |  0.07
Output  | 0.00018136 | 0.00018136 | 0.00018136 |   0.0 |  0.00
Modify  | 0.75549    | 0.75549    | 0.75549    |   0.0 |  0.34
Other   |            | 0.1005     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.742415897681, Press = 1.74540043383842
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -22736.861   -22736.861   -22909.251   -22909.251    333.49965    333.49965     60703.52     60703.52    146.90102    146.90102 
   27000   -22733.563   -22733.563   -22905.217   -22905.217    332.07603    332.07603    60757.806    60757.806   -1814.1101   -1814.1101 
Loop time of 216.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.160 hours/ns, 4.617 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    | 215.59     | 215.59     | 215.59     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15288    | 0.15288    | 0.15288    |   0.0 |  0.07
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.73784    | 0.73784    | 0.73784    |   0.0 |  0.34
Other   |            | 0.1        |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311930.0 ave      311930 max      311930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311930
Ave neighs/atom = 77.982500
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 = 333.754346987304, Press = -0.250997152823967
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22733.563   -22733.563   -22905.217   -22905.217    332.07603    332.07603    60757.806    60757.806   -1814.1101   -1814.1101 
   28000   -22740.717   -22740.717   -22911.533   -22911.533    330.45474    330.45474    60711.404    60711.404   -509.01238   -509.01238 
Loop time of 209.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.160 hours/ns, 4.776 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    | 208.43     | 208.43     | 208.43     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14883    | 0.14883    | 0.14883    |   0.0 |  0.07
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.69929    | 0.69929    | 0.69929    |   0.0 |  0.33
Other   |            | 0.09718    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311920.0 ave      311920 max      311920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311920
Ave neighs/atom = 77.980000
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 = 333.810192034466, Press = 0.477580415870289
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -22740.717   -22740.717   -22911.533   -22911.533    330.45474    330.45474    60711.404    60711.404   -509.01238   -509.01238 
   29000    -22735.72    -22735.72   -22908.603   -22908.603    334.45282    334.45282    60706.014    60706.014    252.77249    252.77249 
Loop time of 203.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.479 hours/ns, 4.918 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    | 202.42     | 202.42     | 202.42     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14544    | 0.14544    | 0.14544    |   0.0 |  0.07
Output  | 0.0001805  | 0.0001805  | 0.0001805  |   0.0 |  0.00
Modify  | 0.66902    | 0.66902    | 0.66902    |   0.0 |  0.33
Other   |            | 0.09521    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.781152649243, Press = -1.26493586215594
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -22735.72    -22735.72   -22908.603   -22908.603    334.45282    334.45282    60706.014    60706.014    252.77249    252.77249 
   30000   -22741.623   -22741.623   -22912.331   -22912.331     330.2453     330.2453    60654.112    60654.112    2053.6333    2053.6333 
Loop time of 223.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 62.044 hours/ns, 4.477 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    | 222.33     | 222.33     | 222.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15675    | 0.15675    | 0.15675    |   0.0 |  0.07
Output  | 0.0001861  | 0.0001861  | 0.0001861  |   0.0 |  0.00
Modify  | 0.76991    | 0.76991    | 0.76991    |   0.0 |  0.34
Other   |            | 0.1022     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311924.0 ave      311924 max      311924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311924
Ave neighs/atom = 77.981000
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 = 333.691007785853, Press = 1.4799858040378
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22741.623   -22741.623   -22912.331   -22912.331     330.2453     330.2453    60654.112    60654.112    2053.6333    2053.6333 
   31000   -22737.393   -22737.393   -22906.111   -22906.111    326.39713    326.39713    60744.896    60744.896   -1351.5739   -1351.5739 
Loop time of 206.164 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.268 hours/ns, 4.851 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    | 205.24     | 205.24     | 205.24     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14748    | 0.14748    | 0.14748    |   0.0 |  0.07
Output  | 0.00022051 | 0.00022051 | 0.00022051 |   0.0 |  0.00
Modify  | 0.68238    | 0.68238    | 0.68238    |   0.0 |  0.33
Other   |            | 0.09562    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311960.0 ave      311960 max      311960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311960
Ave neighs/atom = 77.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.678172476616, Press = 0.822159741247219
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22737.393   -22737.393   -22906.111   -22906.111    326.39713    326.39713    60744.896    60744.896   -1351.5739   -1351.5739 
   32000   -22739.016   -22739.016   -22911.235   -22911.235    333.16967    333.16967    60651.095    60651.095    2362.6107    2362.6107 
Loop time of 203.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.664 hours/ns, 4.902 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    | 203.08     | 203.08     | 203.08     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14561    | 0.14561    | 0.14561    |   0.0 |  0.07
Output  | 0.00018129 | 0.00018129 | 0.00018129 |   0.0 |  0.00
Modify  | 0.66915    | 0.66915    | 0.66915    |   0.0 |  0.33
Other   |            | 0.09484    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311942.0 ave      311942 max      311942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
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 = 333.656497668103, Press = 0.574250699275031
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -22739.016   -22739.016   -22911.235   -22911.235    333.16967    333.16967    60651.095    60651.095    2362.6107    2362.6107 
   33000   -22736.128   -22736.128   -22908.765   -22908.765     333.9785     333.9785     60749.44     60749.44   -1921.1545   -1921.1545 
Loop time of 229.1 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.639 hours/ns, 4.365 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    | 228.02     | 228.02     | 228.02     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16037    | 0.16037    | 0.16037    |   0.0 |  0.07
Output  | 0.00018194 | 0.00018194 | 0.00018194 |   0.0 |  0.00
Modify  | 0.81479    | 0.81479    | 0.81479    |   0.0 |  0.36
Other   |            | 0.1058     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.600025539853, Press = -0.131092987681956
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -22736.128   -22736.128   -22908.765   -22908.765     333.9785     333.9785     60749.44     60749.44   -1921.1545   -1921.1545 
   34000   -22736.059   -22736.059   -22907.515   -22907.515    331.69477    331.69477     60714.41     60714.41   -125.78999   -125.78999 
Loop time of 234.579 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.161 hours/ns, 4.263 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.43     | 233.43     | 233.43     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16765    | 0.16765    | 0.16765    |   0.0 |  0.07
Output  | 0.00018384 | 0.00018384 | 0.00018384 |   0.0 |  0.00
Modify  | 0.86853    | 0.86853    | 0.86853    |   0.0 |  0.37
Other   |            | 0.1095     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311898.0 ave      311898 max      311898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311898
Ave neighs/atom = 77.974500
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 = 333.546664256184, Press = -1.44249222025167
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -22736.059   -22736.059   -22907.515   -22907.515    331.69477    331.69477     60714.41     60714.41   -125.78999   -125.78999 
   35000    -22741.38    -22741.38   -22911.133   -22911.133    328.39824    328.39824    60647.723    60647.723    2428.7209    2428.7209 
Loop time of 235.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.355 hours/ns, 4.250 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    | 234.15     | 234.15     | 234.15     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16453    | 0.16453    | 0.16453    |   0.0 |  0.07
Output  | 0.00017821 | 0.00017821 | 0.00017821 |   0.0 |  0.00
Modify  | 0.85294    | 0.85294    | 0.85294    |   0.0 |  0.36
Other   |            | 0.108      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311924.0 ave      311924 max      311924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311924
Ave neighs/atom = 77.981000
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 = 333.470304961085, Press = 0.790672912590728
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -22741.38    -22741.38   -22911.133   -22911.133    328.39824    328.39824    60647.723    60647.723    2428.7209    2428.7209 
   36000   -22739.657   -22739.657   -22909.596   -22909.596    328.75835    328.75835    60754.775    60754.775   -2291.1564   -2291.1564 
Loop time of 225.955 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.765 hours/ns, 4.426 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    | 224.9      | 224.9      | 224.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15993    | 0.15993    | 0.15993    |   0.0 |  0.07
Output  | 0.00027142 | 0.00027142 | 0.00027142 |   0.0 |  0.00
Modify  | 0.79261    | 0.79261    | 0.79261    |   0.0 |  0.35
Other   |            | 0.1051     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311940.0 ave      311940 max      311940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311940
Ave neighs/atom = 77.985000
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 = 333.457229177064, Press = 1.17878543176056
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -22739.657   -22739.657   -22909.596   -22909.596    328.75835    328.75835    60754.775    60754.775   -2291.1564   -2291.1564 
   37000   -22730.284   -22730.284   -22904.946   -22904.946    337.89625    337.89625    60737.418    60737.418   -795.10651   -795.10651 
Loop time of 222.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.883 hours/ns, 4.489 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    | 221.75     | 221.75     | 221.75     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15691    | 0.15691    | 0.15691    |   0.0 |  0.07
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.76978    | 0.76978    | 0.76978    |   0.0 |  0.35
Other   |            | 0.1029     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
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 = 333.494298747289, Press = -1.12081515401889
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -22730.284   -22730.284   -22904.946   -22904.946    337.89625    337.89625    60737.418    60737.418   -795.10651   -795.10651 
   38000   -22734.198   -22734.198   -22909.804   -22909.804    339.72127    339.72127    60686.144    60686.144    927.70613    927.70613 
Loop time of 224.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.236 hours/ns, 4.463 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    | 223        | 223        | 223        |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15905    | 0.15905    | 0.15905    |   0.0 |  0.07
Output  | 0.00017951 | 0.00017951 | 0.00017951 |   0.0 |  0.00
Modify  | 0.78246    | 0.78246    | 0.78246    |   0.0 |  0.35
Other   |            | 0.103      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311908.0 ave      311908 max      311908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
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 = 333.527410525982, Press = -0.0616998558637646
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -22734.198   -22734.198   -22909.804   -22909.804    339.72127    339.72127    60686.144    60686.144    927.70613    927.70613 
   39000   -22742.098   -22742.098   -22909.836   -22909.836    324.50189    324.50189    60744.896    60744.896   -1866.7536   -1866.7536 
Loop time of 235.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.525 hours/ns, 4.239 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    | 234.76     | 234.76     | 234.76     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16575    | 0.16575    | 0.16575    |   0.0 |  0.07
Output  | 0.00018248 | 0.00018248 | 0.00018248 |   0.0 |  0.00
Modify  | 0.85077    | 0.85077    | 0.85077    |   0.0 |  0.36
Other   |            | 0.108      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
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 = 333.527486731077, Press = 0.171500870674199
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -22742.098   -22742.098   -22909.836   -22909.836    324.50189    324.50189    60744.896    60744.896   -1866.7536   -1866.7536 
   40000   -22734.095   -22734.095   -22906.411   -22906.411     333.3565     333.3565    60695.017    60695.017    929.65047    929.65047 
Loop time of 230.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.128 hours/ns, 4.332 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    | 229.77     | 229.77     | 229.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16178    | 0.16178    | 0.16178    |   0.0 |  0.07
Output  | 0.00018239 | 0.00018239 | 0.00018239 |   0.0 |  0.00
Modify  | 0.82275    | 0.82275    | 0.82275    |   0.0 |  0.36
Other   |            | 0.1074     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311954.0 ave      311954 max      311954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
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 = 333.489716167138, Press = -0.468881897906746
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -22734.095   -22734.095   -22906.411   -22906.411     333.3565     333.3565    60695.017    60695.017    929.65047    929.65047 
   41000   -22743.888   -22743.888   -22910.116   -22910.116    321.58051    321.58051    60633.024    60633.024    3306.4267    3306.4267 
Loop time of 233.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.856 hours/ns, 4.283 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    | 232.38     | 232.38     | 232.38     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16515    | 0.16515    | 0.16515    |   0.0 |  0.07
Output  | 0.00058137 | 0.00058137 | 0.00058137 |   0.0 |  0.00
Modify  | 0.83092    | 0.83092    | 0.83092    |   0.0 |  0.36
Other   |            | 0.107      |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311948.0 ave      311948 max      311948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311948
Ave neighs/atom = 77.987000
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 = 333.437865851966, Press = 0.563062211513564
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -22743.888   -22743.888   -22910.116   -22910.116    321.58051    321.58051    60633.024    60633.024    3306.4267    3306.4267 
   42000   -22734.268   -22734.268   -22909.095   -22909.095    338.21474    338.21474    60746.097    60746.097   -1662.6194   -1662.6194 
Loop time of 235.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.294 hours/ns, 4.254 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    | 233.92     | 233.92     | 233.92     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16613    | 0.16613    | 0.16613    |   0.0 |  0.07
Output  | 0.00017965 | 0.00017965 | 0.00017965 |   0.0 |  0.00
Modify  | 0.86114    | 0.86114    | 0.86114    |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311964.0 ave      311964 max      311964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
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 = 333.407940760303, Press = 1.01520888808909
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -22734.268   -22734.268   -22909.095   -22909.095    338.21474    338.21474    60746.097    60746.097   -1662.6194   -1662.6194 
   43000   -22733.113   -22733.113   -22908.042   -22908.042    338.41155    338.41155    60666.366    60666.366    2143.6117    2143.6117 
Loop time of 234.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.231 hours/ns, 4.258 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    | 233.72     | 233.72     | 233.72     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16487    | 0.16487    | 0.16487    |   0.0 |  0.07
Output  | 0.00021864 | 0.00021864 | 0.00021864 |   0.0 |  0.00
Modify  | 0.83885    | 0.83885    | 0.83885    |   0.0 |  0.36
Other   |            | 0.1072     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311932.0 ave      311932 max      311932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311932
Ave neighs/atom = 77.983000
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 = 333.411092154825, Press = -1.1576334609917
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -22733.113   -22733.113   -22908.042   -22908.042    338.41155    338.41155    60666.366    60666.366    2143.6117    2143.6117 
   44000   -22736.752   -22736.752   -22909.831   -22909.831    334.83419    334.83419    60676.494    60676.494    1431.5244    1431.5244 
Loop time of 220.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.285 hours/ns, 4.533 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    | 219.6      | 219.6      | 219.6      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15713    | 0.15713    | 0.15713    |   0.0 |  0.07
Output  | 0.00021566 | 0.00021566 | 0.00021566 |   0.0 |  0.00
Modify  | 0.76698    | 0.76698    | 0.76698    |   0.0 |  0.35
Other   |            | 0.1033     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311938.0 ave      311938 max      311938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311938
Ave neighs/atom = 77.984500
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 = 333.456855514368, Press = 1.74593975535813
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -22736.752   -22736.752   -22909.831   -22909.831    334.83419    334.83419    60676.494    60676.494    1431.5244    1431.5244 
   45000   -22735.791   -22735.791   -22910.325   -22910.325    337.64909    337.64909    60750.405    60750.405   -2073.3048   -2073.3048 
Loop time of 232.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.600 hours/ns, 4.300 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    | 231.43     | 231.43     | 231.43     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16585    | 0.16585    | 0.16585    |   0.0 |  0.07
Output  | 0.00021822 | 0.00021822 | 0.00021822 |   0.0 |  0.00
Modify  | 0.85042    | 0.85042    | 0.85042    |   0.0 |  0.37
Other   |            | 0.1089     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311908.0 ave      311908 max      311908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
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 = 333.434313151486, Press = -0.377845049625847
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -22735.791   -22735.791   -22910.325   -22910.325    337.64909    337.64909    60750.405    60750.405   -2073.3048   -2073.3048 
   46000    -22738.04    -22738.04   -22909.938   -22909.938    332.54706    332.54706    60709.562    60709.562   -127.76169   -127.76169 
Loop time of 237.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.916 hours/ns, 4.214 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 236.18     | 236.18     | 236.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16574    | 0.16574    | 0.16574    |   0.0 |  0.07
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.83784    | 0.83784    | 0.83784    |   0.0 |  0.35
Other   |            | 0.1079     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 77.980500
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 = 333.448422463427, Press = -1.16469390217705
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -22738.04    -22738.04   -22909.938   -22909.938    332.54706    332.54706    60709.562    60709.562   -127.76169   -127.76169 
   47000   -22736.762   -22736.762   -22911.425   -22911.425    337.89741    337.89741    60637.777    60637.777    3096.3758    3096.3758 
Loop time of 235.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.369 hours/ns, 4.249 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    | 234.19     | 234.19     | 234.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16753    | 0.16753    | 0.16753    |   0.0 |  0.07
Output  | 0.00024866 | 0.00024866 | 0.00024866 |   0.0 |  0.00
Modify  | 0.86149    | 0.86149    | 0.86149    |   0.0 |  0.37
Other   |            | 0.1085     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311928.0 ave      311928 max      311928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311928
Ave neighs/atom = 77.982000
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 = 333.409716457589, Press = 0.228005581315229
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -22736.762   -22736.762   -22911.425   -22911.425    337.89741    337.89741    60637.777    60637.777    3096.3758    3096.3758 
   48000   -22739.296   -22739.296   -22906.211   -22906.211    322.90968    322.90968    60762.789    60762.789   -2215.5046   -2215.5046 
Loop time of 213.558 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.322 hours/ns, 4.683 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    | 212.58     | 212.58     | 212.58     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15176    | 0.15176    | 0.15176    |   0.0 |  0.07
Output  | 0.00018255 | 0.00018255 | 0.00018255 |   0.0 |  0.00
Modify  | 0.72517    | 0.72517    | 0.72517    |   0.0 |  0.34
Other   |            | 0.1014     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311944.0 ave      311944 max      311944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311944
Ave neighs/atom = 77.986000
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 = 333.443764275516, Press = 0.374498027463257
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -22739.296   -22739.296   -22906.211   -22906.211    322.90968    322.90968    60762.789    60762.789   -2215.5046   -2215.5046 
   49000   -22732.559   -22732.559   -22907.754   -22907.754    338.92679    338.92679    60749.833    60749.833   -1653.1514   -1653.1514 
Loop time of 235.295 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.360 hours/ns, 4.250 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    | 234.16     | 234.16     | 234.16     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16723    | 0.16723    | 0.16723    |   0.0 |  0.07
Output  | 0.00018233 | 0.00018233 | 0.00018233 |   0.0 |  0.00
Modify  | 0.86177    | 0.86177    | 0.86177    |   0.0 |  0.37
Other   |            | 0.1091     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311934.0 ave      311934 max      311934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311934
Ave neighs/atom = 77.983500
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 = 333.481545763827, Press = -0.374900989512272
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -22732.559   -22732.559   -22907.754   -22907.754    338.92679    338.92679    60749.833    60749.833   -1653.1514   -1653.1514 
   50000   -22738.556   -22738.556   -22909.383   -22909.383    330.47527    330.47527    60668.015    60668.015    1801.0237    1801.0237 
Loop time of 223.53 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 62.092 hours/ns, 4.474 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.46     | 222.46     | 222.46     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16065    | 0.16065    | 0.16065    |   0.0 |  0.07
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.79907    | 0.79907    | 0.79907    |   0.0 |  0.36
Other   |            | 0.1055     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311912.0 ave      311912 max      311912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
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 = 333.444618616176, Press = -0.512911637851405
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -22738.556   -22738.556   -22909.383   -22909.383    330.47527    330.47527    60668.015    60668.015    1801.0237    1801.0237 
   51000   -22738.311   -22738.311   -22910.743   -22910.743    333.58047    333.58047    60702.654    60702.654   -26.155785   -26.155785 
Loop time of 230.333 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.981 hours/ns, 4.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    | 229.23     | 229.23     | 229.23     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16382    | 0.16382    | 0.16382    |   0.0 |  0.07
Output  | 0.00023493 | 0.00023493 | 0.00023493 |   0.0 |  0.00
Modify  | 0.82738    | 0.82738    | 0.82738    |   0.0 |  0.36
Other   |            | 0.1084     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311942.0 ave      311942 max      311942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
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 = 333.432197181675, Press = 0.820693645195441
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -22738.311   -22738.311   -22910.743   -22910.743    333.58047    333.58047    60702.654    60702.654   -26.155785   -26.155785 
   52000   -22734.706   -22734.706   -22907.875   -22907.875     335.0071     335.0071    60775.626    60775.626    -2986.179    -2986.179 
Loop time of 216.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 60.055 hours/ns, 4.625 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    | 215.21     | 215.21     | 215.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15419    | 0.15419    | 0.15419    |   0.0 |  0.07
Output  | 0.0001827  | 0.0001827  | 0.0001827  |   0.0 |  0.00
Modify  | 0.73721    | 0.73721    | 0.73721    |   0.0 |  0.34
Other   |            | 0.1006     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311960.0 ave      311960 max      311960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311960
Ave neighs/atom = 77.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.408619222993, Press = -0.631419325219215
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -22734.706   -22734.706   -22907.875   -22907.875     335.0071     335.0071    60775.626    60775.626    -2986.179    -2986.179 
   53000   -22741.063   -22741.063   -22914.536   -22914.536    335.59537    335.59537    60654.199    60654.199     1923.309     1923.309 
Loop time of 202.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.325 hours/ns, 4.932 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    | 201.86     | 201.86     | 201.86     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14538    | 0.14538    | 0.14538    |   0.0 |  0.07
Output  | 0.00022622 | 0.00022622 | 0.00022622 |   0.0 |  0.00
Modify  | 0.66686    | 0.66686    | 0.66686    |   0.0 |  0.33
Other   |            | 0.09624    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311910.0 ave      311910 max      311910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311910
Ave neighs/atom = 77.977500
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 = 333.370074753448, Press = -0.31578546520363
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -22741.063   -22741.063   -22914.536   -22914.536    335.59537    335.59537    60654.199    60654.199     1923.309     1923.309 
   54000   -22733.824   -22733.824   -22906.199   -22906.199    333.47031    333.47031    60743.696    60743.696   -1211.6035   -1211.6035 
Loop time of 212.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.407 ns/day, 58.941 hours/ns, 4.713 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    | 211.22     | 211.22     | 211.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15273    | 0.15273    | 0.15273    |   0.0 |  0.07
Output  | 0.00028087 | 0.00028087 | 0.00028087 |   0.0 |  0.00
Modify  | 0.71743    | 0.71743    | 0.71743    |   0.0 |  0.34
Other   |            | 0.09864    |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311950.0 ave      311950 max      311950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311950
Ave neighs/atom = 77.987500
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 = 333.329533471747, Press = -0.503241521876558
next a
jump SELF top
variable a loop 2000
run 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 = 13 13 13
  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.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -22733.824   -22733.824   -22906.199   -22906.199    333.47031    333.47031    60743.696    60743.696   -1211.6035   -1211.6035 
   55000   -22737.816   -22737.816   -22909.663   -22909.663    332.44939    332.44939    60656.231    60656.231     2381.107     2381.107 
Loop time of 227.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.205 hours/ns, 4.395 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    | 226.48     | 226.48     | 226.48     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15994    | 0.15994    | 0.15994    |   0.0 |  0.07
Output  | 0.00020731 | 0.00020731 | 0.00020731 |   0.0 |  0.00
Modify  | 0.79399    | 0.79399    | 0.79399    |   0.0 |  0.35
Other   |            | 0.1059     |            |       |  0.05

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311940.0 ave      311940 max      311940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311940
Ave neighs/atom = 77.985000
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
60709.1042624535

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0