# 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.9173715934157367*${_u_distance}
variable latticeconst_converted equal 3.9173715934157367*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737159341574
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_KimLee_2006_PtFe__MO_343168101490_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.2017852415    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.2017852415/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.2017852415/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.2017852415/(1*1*${_u_distance})
variable      V0_metal equal 60115.2017852415/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 60115.2017852415*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 60115.2017852415 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_343168101490_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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.202    60115.202    3059.7668    3059.7668 
    1000   -22727.252   -22727.252   -22909.134   -22909.134    351.86297    351.86297      60793.1      60793.1   -3709.8382   -3709.8382 
Loop time of 184.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.468 ns/day, 51.300 hours/ns, 5.415 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    | 183.76     | 183.76     | 183.76     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.08
Output  | 0.0002216  | 0.0002216  | 0.0002216  |   0.0 |  0.00
Modify  | 0.67153    | 0.67153    | 0.67153    |   0.0 |  0.36
Other   |            | 0.09645    |            |       |  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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.8382   -3709.8382 
    2000   -22736.054   -22736.054   -22913.154   -22913.154    342.61214    342.61214    60708.229    60708.229   -525.31784   -525.31784 
Loop time of 226.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 62.984 hours/ns, 4.410 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.63     | 225.63     | 225.63     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17276    | 0.17276    | 0.17276    |   0.0 |  0.08
Output  | 0.00021675 | 0.00021675 | 0.00021675 |   0.0 |  0.00
Modify  | 0.83053    | 0.83053    | 0.83053    |   0.0 |  0.37
Other   |            | 0.1081     |            |       |  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:      310034.0 ave      310034 max      310034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310034
Ave neighs/atom = 77.508500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.31784   -525.31784 
    3000   -22738.201   -22738.201   -22913.914   -22913.914    339.92749    339.92749    60709.687    60709.687   -759.35413   -759.35413 
Loop time of 221.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.393 hours/ns, 4.525 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    | 219.95     | 219.95     | 219.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16589    | 0.16589    | 0.16589    |   0.0 |  0.08
Output  | 0.00021429 | 0.00021429 | 0.00021429 |   0.0 |  0.00
Modify  | 0.79533    | 0.79533    | 0.79533    |   0.0 |  0.36
Other   |            | 0.1046     |            |       |  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:      310294.0 ave      310294 max      310294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310294
Ave neighs/atom = 77.573500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.35413   -759.35413 
    4000   -22732.743   -22732.743   -22909.708   -22909.708    342.35041    342.35041    60694.946    60694.946    835.29534    835.29534 
Loop time of 220.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.241 hours/ns, 4.536 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    | 219.4      | 219.4      | 219.4      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16644    | 0.16644    | 0.16644    |   0.0 |  0.08
Output  | 0.0002709  | 0.0002709  | 0.0002709  |   0.0 |  0.00
Modify  | 0.79442    | 0.79442    | 0.79442    |   0.0 |  0.36
Other   |            | 0.1041     |            |       |  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:      310088.0 ave      310088 max      310088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310088
Ave neighs/atom = 77.522000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.29534    835.29534 
    5000   -22738.273   -22738.273   -22906.813   -22906.813    326.05207    326.05207    60703.787    60703.787     378.6242     378.6242 
Loop time of 222.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.801 hours/ns, 4.495 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.4      | 221.4      | 221.4      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16724    | 0.16724    | 0.16724    |   0.0 |  0.08
Output  | 0.00017878 | 0.00017878 | 0.00017878 |   0.0 |  0.00
Modify  | 0.80955    | 0.80955    | 0.80955    |   0.0 |  0.36
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:      310368.0 ave      310368 max      310368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310368
Ave neighs/atom = 77.592000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.649616183053, Press = 323.638281675538
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.6242     378.6242 
    6000   -22737.637   -22737.637    -22911.02    -22911.02    335.41966    335.41966    60683.166    60683.166    957.09305    957.09305 
Loop time of 222.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.714 hours/ns, 4.501 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.07     | 221.07     | 221.07     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16717    | 0.16717    | 0.16717    |   0.0 |  0.08
Output  | 0.00018087 | 0.00018087 | 0.00018087 |   0.0 |  0.00
Modify  | 0.8281     | 0.8281     | 0.8281     |   0.0 |  0.37
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:      309946.0 ave      309946 max      309946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309946
Ave neighs/atom = 77.486500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.595166274385, Press = -13.442072738168
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.09305    957.09305 
    7000   -22733.996   -22733.996    -22907.92    -22907.92    336.46831    336.46831    60721.483    60721.483   -450.13221   -450.13221 
Loop time of 220.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.345 hours/ns, 4.528 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.75     | 219.75     | 219.75     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16422    | 0.16422    | 0.16422    |   0.0 |  0.07
Output  | 0.00018098 | 0.00018098 | 0.00018098 |   0.0 |  0.00
Modify  | 0.81786    | 0.81786    | 0.81786    |   0.0 |  0.37
Other   |            | 0.1056     |            |       |  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:      310282.0 ave      310282 max      310282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310282
Ave neighs/atom = 77.570500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.972778049673, Press = 0.69153126175037
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.13221   -450.13221 
    8000   -22738.779   -22738.779   -22910.184   -22910.184    331.59348    331.59348    60701.369    60701.369    246.58118    246.58118 
Loop time of 220.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.134 hours/ns, 4.544 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    | 219        | 219        | 219        |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16489    | 0.16489    | 0.16489    |   0.0 |  0.07
Output  | 0.00018133 | 0.00018133 | 0.00018133 |   0.0 |  0.00
Modify  | 0.81263    | 0.81263    | 0.81263    |   0.0 |  0.37
Other   |            | 0.1047     |            |       |  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:      309858.0 ave      309858 max      309858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309858
Ave neighs/atom = 77.464500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.23095667997, Press = -15.1089937192827
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.59348    331.59348    60701.369    60701.369    246.58118    246.58118 
    9000   -22732.156   -22732.156   -22908.229   -22908.229    340.62351    340.62351    60665.572    60665.572    2131.3434    2131.3434 
Loop time of 222.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.701 hours/ns, 4.502 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    | 221.03     | 221.03     | 221.03     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16528    | 0.16528    | 0.16528    |   0.0 |  0.07
Output  | 0.00018373 | 0.00018373 | 0.00018373 |   0.0 |  0.00
Modify  | 0.82294    | 0.82294    | 0.82294    |   0.0 |  0.37
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:      310318.0 ave      310318 max      310318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310318
Ave neighs/atom = 77.579500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.421333993142, Press = 5.19293052909802
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.62351    340.62351    60665.572    60665.572    2131.3434    2131.3434 
   10000   -22738.882   -22738.882   -22909.913   -22909.913    330.87124    330.87124    60748.362    60748.362   -1982.6405   -1982.6405 
Loop time of 196.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.674 hours/ns, 5.081 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    | 195.87     | 195.87     | 195.87     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15343    | 0.15343    | 0.15343    |   0.0 |  0.08
Output  | 0.00018179 | 0.00018179 | 0.00018179 |   0.0 |  0.00
Modify  | 0.7036     | 0.7036     | 0.7036     |   0.0 |  0.36
Other   |            | 0.09549    |            |       |  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:      310142.0 ave      310142 max      310142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310142
Ave neighs/atom = 77.535500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.762933772909, Press = -4.45659431239832
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.87124    330.87124    60748.362    60748.362   -1982.6405   -1982.6405 
   11000    -22732.41    -22732.41   -22906.032   -22906.032    335.88435    335.88435     60700.94     60700.94    836.76039    836.76039 
Loop time of 212.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.407 ns/day, 58.975 hours/ns, 4.710 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.26     | 211.26     | 211.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16315    | 0.16315    | 0.16315    |   0.0 |  0.08
Output  | 0.00021994 | 0.00021994 | 0.00021994 |   0.0 |  0.00
Modify  | 0.78304    | 0.78304    | 0.78304    |   0.0 |  0.37
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:      310086.0 ave      310086 max      310086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310086
Ave neighs/atom = 77.521500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.640722856104, Press = -11.2858507782808
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.41    -22732.41   -22906.032   -22906.032    335.88435    335.88435     60700.94     60700.94    836.76039    836.76039 
   12000   -22738.942   -22738.942   -22911.471   -22911.471    333.76872    333.76872    60711.354    60711.354   -379.67911   -379.67911 
Loop time of 215.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.825 hours/ns, 4.643 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    | 214.31     | 214.31     | 214.31     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16328    | 0.16328    | 0.16328    |   0.0 |  0.08
Output  | 0.00029664 | 0.00029664 | 0.00029664 |   0.0 |  0.00
Modify  | 0.79671    | 0.79671    | 0.79671    |   0.0 |  0.37
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:      309940.0 ave      309940 max      309940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309940
Ave neighs/atom = 77.485000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.658610216932, Press = 4.76178344457119
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.942   -22738.942   -22911.471   -22911.471    333.76872    333.76872    60711.354    60711.354   -379.67911   -379.67911 
   13000   -22732.329   -22732.329   -22906.987   -22906.987    337.88681    337.88681    60758.603    60758.603   -1946.5097   -1946.5097 
Loop time of 216.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.245 hours/ns, 4.611 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 215.82     | 215.82     | 215.82     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16278    | 0.16278    | 0.16278    |   0.0 |  0.08
Output  | 0.00018138 | 0.00018138 | 0.00018138 |   0.0 |  0.00
Modify  | 0.79971    | 0.79971    | 0.79971    |   0.0 |  0.37
Other   |            | 0.104      |            |       |  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:      310178.0 ave      310178 max      310178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310178
Ave neighs/atom = 77.544500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.782776825073, Press = -1.51977852529333
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.329   -22732.329   -22906.987   -22906.987    337.88681    337.88681    60758.603    60758.603   -1946.5097   -1946.5097 
   14000   -22737.395   -22737.395   -22909.662   -22909.662    333.26184    333.26184    60677.874    60677.874    1276.9847    1276.9847 
Loop time of 214.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.595 hours/ns, 4.661 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    | 213.48     | 213.48     | 213.48     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16188    | 0.16188    | 0.16188    |   0.0 |  0.08
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.79205    | 0.79205    | 0.79205    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  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:      309954.0 ave      309954 max      309954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309954
Ave neighs/atom = 77.488500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.945693858614, Press = -2.64688936842619
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.395   -22737.395   -22909.662   -22909.662    333.26184    333.26184    60677.874    60677.874    1276.9847    1276.9847 
   15000   -22734.131   -22734.131   -22906.708   -22906.708    333.86039    333.86039    60739.753    60739.753   -1118.1297   -1118.1297 
Loop time of 217.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.416 hours/ns, 4.598 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    | 216.43     | 216.43     | 216.43     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16363    | 0.16363    | 0.16363    |   0.0 |  0.08
Output  | 0.00061662 | 0.00061662 | 0.00061662 |   0.0 |  0.00
Modify  | 0.80143    | 0.80143    | 0.80143    |   0.0 |  0.37
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:      310154.0 ave      310154 max      310154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310154
Ave neighs/atom = 77.538500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.809917627646, Press = 2.70076890143741
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22734.131   -22734.131   -22906.708   -22906.708    333.86039    333.86039    60739.753    60739.753   -1118.1297   -1118.1297 
   16000    -22737.85    -22737.85   -22909.095   -22909.095    331.28609    331.28609    60728.015    60728.015   -935.49524   -935.49524 
Loop time of 219.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.097 hours/ns, 4.547 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    | 218.86     | 218.86     | 218.86     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16561    | 0.16561    | 0.16561    |   0.0 |  0.08
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.8187     | 0.8187     | 0.8187     |   0.0 |  0.37
Other   |            | 0.1047     |            |       |  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:      309878.0 ave      309878 max      309878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309878
Ave neighs/atom = 77.469500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.829977065877, Press = -4.41673924063348
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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    -22737.85    -22737.85   -22909.095   -22909.095    331.28609    331.28609    60728.015    60728.015   -935.49524   -935.49524 
   17000   -22733.987   -22733.987   -22906.462   -22906.462    333.66383    333.66383    60691.774    60691.774    1198.2149    1198.2149 
Loop time of 213.786 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.385 hours/ns, 4.678 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.73     | 212.73     | 212.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16292    | 0.16292    | 0.16292    |   0.0 |  0.08
Output  | 0.00023275 | 0.00023275 | 0.00023275 |   0.0 |  0.00
Modify  | 0.789      | 0.789      | 0.789      |   0.0 |  0.37
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:      309928.0 ave      309928 max      309928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309928
Ave neighs/atom = 77.482000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731704748074, Press = -0.227394950720934
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22733.987   -22733.987   -22906.462   -22906.462    333.66383    333.66383    60691.774    60691.774    1198.2149    1198.2149 
   18000    -22742.86    -22742.86   -22911.813   -22911.813    326.85062    326.85062    60679.453    60679.453    1006.1235    1006.1235 
Loop time of 218.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.574 hours/ns, 4.586 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    | 216.98     | 216.98     | 216.98     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16591    | 0.16591    | 0.16591    |   0.0 |  0.08
Output  | 0.00018761 | 0.00018761 | 0.00018761 |   0.0 |  0.00
Modify  | 0.8132     | 0.8132     | 0.8132     |   0.0 |  0.37
Other   |            | 0.1044     |            |       |  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:      309994.0 ave      309994 max      309994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309994
Ave neighs/atom = 77.498500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.574793401816, Press = 0.581845385207999
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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    -22742.86    -22742.86   -22911.813   -22911.813    326.85062    326.85062    60679.453    60679.453    1006.1235    1006.1235 
   19000   -22734.177   -22734.177   -22908.742   -22908.742    337.70761    337.70761    60762.258    60762.258   -2331.2541   -2331.2541 
Loop time of 204.348 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.763 hours/ns, 4.894 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.35     | 203.35     | 203.35     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15891    | 0.15891    | 0.15891    |   0.0 |  0.08
Output  | 0.00018075 | 0.00018075 | 0.00018075 |   0.0 |  0.00
Modify  | 0.74318    | 0.74318    | 0.74318    |   0.0 |  0.36
Other   |            | 0.0986     |            |       |  0.05

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

Total # of neighbors = 310222
Ave neighs/atom = 77.555500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.529608214457, Press = -3.04000214427393
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22734.177   -22734.177   -22908.742   -22908.742    337.70761    337.70761    60762.258    60762.258   -2331.2541   -2331.2541 
   20000    -22735.49    -22735.49   -22909.781   -22909.781    337.17715    337.17715    60639.323    60639.323    3300.7431    3300.7431 
Loop time of 196.768 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.658 hours/ns, 5.082 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    | 195.82     | 195.82     | 195.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15379    | 0.15379    | 0.15379    |   0.0 |  0.08
Output  | 0.00023462 | 0.00023462 | 0.00023462 |   0.0 |  0.00
Modify  | 0.70206    | 0.70206    | 0.70206    |   0.0 |  0.36
Other   |            | 0.09641    |            |       |  0.05

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

Total # of neighbors = 309942
Ave neighs/atom = 77.485500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.432481355988, Press = -3.53114768011785
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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    -22735.49    -22735.49   -22909.781   -22909.781    337.17715    337.17715    60639.323    60639.323    3300.7431    3300.7431 
   21000   -22737.585   -22737.585   -22909.693   -22909.693    332.95411    332.95411    60631.416    60631.416    3603.9787    3603.9787 
Loop time of 217.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.436 hours/ns, 4.596 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.5      | 216.5      | 216.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1632     | 0.1632     | 0.1632     |   0.0 |  0.08
Output  | 0.00018162 | 0.00018162 | 0.00018162 |   0.0 |  0.00
Modify  | 0.80577    | 0.80577    | 0.80577    |   0.0 |  0.37
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:      310256.0 ave      310256 max      310256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310256
Ave neighs/atom = 77.564000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.520770325066, Press = 3.4762517272628
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.585   -22737.585   -22909.693   -22909.693    332.95411    332.95411    60631.416    60631.416    3603.9787    3603.9787 
   22000   -22737.094   -22737.094    -22909.98    -22909.98    334.45921    334.45921    60718.363    60718.363   -442.29589   -442.29589 
Loop time of 221.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.517 hours/ns, 4.515 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    | 220.36     | 220.36     | 220.36     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16668    | 0.16668    | 0.16668    |   0.0 |  0.08
Output  | 0.00017803 | 0.00017803 | 0.00017803 |   0.0 |  0.00
Modify  | 0.8272     | 0.8272     | 0.8272     |   0.0 |  0.37
Other   |            | 0.1054     |            |       |  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:      310294.0 ave      310294 max      310294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310294
Ave neighs/atom = 77.573500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.522664802933, Press = 1.02535284624266
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22737.094   -22737.094    -22909.98    -22909.98    334.45921    334.45921    60718.363    60718.363   -442.29589   -442.29589 
   23000   -22737.252   -22737.252   -22910.566   -22910.566    335.28707    335.28707    60703.889    60703.889    65.464144    65.464144 
Loop time of 222.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.926 hours/ns, 4.486 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    | 221.83     | 221.83     | 221.83     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16778    | 0.16778    | 0.16778    |   0.0 |  0.08
Output  | 0.00032687 | 0.00032687 | 0.00032687 |   0.0 |  0.00
Modify  | 0.83488    | 0.83488    | 0.83488    |   0.0 |  0.37
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:      310232.0 ave      310232 max      310232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310232
Ave neighs/atom = 77.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.381824600847, Press = -0.776724034855628
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22737.252   -22737.252   -22910.566   -22910.566    335.28707    335.28707    60703.889    60703.889    65.464144    65.464144 
   24000   -22739.891   -22739.891   -22910.295   -22910.295    329.65755    329.65755    60732.025    60732.025    -1322.947    -1322.947 
Loop time of 201.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.880 hours/ns, 4.971 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    | 200.19     | 200.19     | 200.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15359    | 0.15359    | 0.15359    |   0.0 |  0.08
Output  | 0.00017827 | 0.00017827 | 0.00017827 |   0.0 |  0.00
Modify  | 0.7237     | 0.7237     | 0.7237     |   0.0 |  0.36
Other   |            | 0.09762    |            |       |  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:      310054.0 ave      310054 max      310054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310054
Ave neighs/atom = 77.513500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.387886530549, Press = -1.90948327783865
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22739.891   -22739.891   -22910.295   -22910.295    329.65755    329.65755    60732.025    60732.025    -1322.947    -1322.947 
   25000    -22739.87    -22739.87   -22909.646   -22909.646    328.44366    328.44366    60673.161    60673.161    1439.1533    1439.1533 
Loop time of 189.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.749 hours/ns, 5.266 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    | 188.99     | 188.99     | 188.99     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14849    | 0.14849    | 0.14849    |   0.0 |  0.08
Output  | 0.00017899 | 0.00017899 | 0.00017899 |   0.0 |  0.00
Modify  | 0.66672    | 0.66672    | 0.66672    |   0.0 |  0.35
Other   |            | 0.0937     |            |       |  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:      309966.0 ave      309966 max      309966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309966
Ave neighs/atom = 77.491500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.376896611831, Press = -2.82985956507789
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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    -22739.87    -22739.87   -22909.646   -22909.646    328.44366    328.44366    60673.161    60673.161    1439.1533    1439.1533 
   26000    -22731.68    -22731.68   -22905.905   -22905.905    337.04953    337.04953    60705.363    60705.363    536.17731    536.17731 
Loop time of 218.069 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.575 hours/ns, 4.586 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    | 217        | 217        | 217        |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16259    | 0.16259    | 0.16259    |   0.0 |  0.07
Output  | 0.00024183 | 0.00024183 | 0.00024183 |   0.0 |  0.00
Modify  | 0.80603    | 0.80603    | 0.80603    |   0.0 |  0.37
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:      310112.0 ave      310112 max      310112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310112
Ave neighs/atom = 77.528000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405874715735, Press = 1.70744539597945
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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    -22731.68    -22731.68   -22905.905   -22905.905    337.04953    337.04953    60705.363    60705.363    536.17731    536.17731 
   27000   -22739.815   -22739.815   -22909.036   -22909.036     327.3684     327.3684    60737.364    60737.364   -1422.7756   -1422.7756 
Loop time of 217.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.441 hours/ns, 4.596 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    | 216.51     | 216.51     | 216.51     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16543    | 0.16543    | 0.16543    |   0.0 |  0.08
Output  | 0.00017842 | 0.00017842 | 0.00017842 |   0.0 |  0.00
Modify  | 0.80446    | 0.80446    | 0.80446    |   0.0 |  0.37
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:      309942.0 ave      309942 max      309942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309942
Ave neighs/atom = 77.485500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.464254316471, Press = -0.0858049564861035
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22739.815   -22739.815   -22909.036   -22909.036     327.3684     327.3684    60737.364    60737.364   -1422.7756   -1422.7756 
   28000   -22732.642   -22732.642   -22906.475   -22906.475     336.2931     336.2931    60727.952    60727.952   -537.31847   -537.31847 
Loop time of 209.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.153 hours/ns, 4.777 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.32     | 208.32     | 208.32     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15916    | 0.15916    | 0.15916    |   0.0 |  0.08
Output  | 0.00021837 | 0.00021837 | 0.00021837 |   0.0 |  0.00
Modify  | 0.76639    | 0.76639    | 0.76639    |   0.0 |  0.37
Other   |            | 0.1018     |            |       |  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:      310054.0 ave      310054 max      310054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310054
Ave neighs/atom = 77.513500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.518068223955, Press = 0.541235171289955
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22732.642   -22732.642   -22906.475   -22906.475     336.2931     336.2931    60727.952    60727.952   -537.31847   -537.31847 
   29000   -22739.387   -22739.387   -22910.422   -22910.422    330.87966    330.87966    60709.777    60709.777   -182.99585   -182.99585 
Loop time of 201.029 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.842 hours/ns, 4.974 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.05     | 200.05     | 200.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15322    | 0.15322    | 0.15322    |   0.0 |  0.08
Output  | 0.0001761  | 0.0001761  | 0.0001761  |   0.0 |  0.00
Modify  | 0.72247    | 0.72247    | 0.72247    |   0.0 |  0.36
Other   |            | 0.09903    |            |       |  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:      309942.0 ave      309942 max      309942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309942
Ave neighs/atom = 77.485500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.557514079772, Press = -1.3457045496502
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22739.387   -22739.387   -22910.422   -22910.422    330.87966    330.87966    60709.777    60709.777   -182.99585   -182.99585 
   30000   -22734.248   -22734.248   -22907.916   -22907.916    335.97336    335.97336    60654.314    60654.314    2704.8745    2704.8745 
Loop time of 212.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.407 ns/day, 58.959 hours/ns, 4.711 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    | 211.21     | 211.21     | 211.21     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16018    | 0.16018    | 0.16018    |   0.0 |  0.08
Output  | 0.00018121 | 0.00018121 | 0.00018121 |   0.0 |  0.00
Modify  | 0.77604    | 0.77604    | 0.77604    |   0.0 |  0.37
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:      310156.0 ave      310156 max      310156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310156
Ave neighs/atom = 77.539000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.614246702205, Press = 1.12586317788299
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22734.248   -22734.248   -22907.916   -22907.916    335.97336    335.97336    60654.314    60654.314    2704.8745    2704.8745 
   31000   -22734.664   -22734.664   -22905.282   -22905.282    330.07346    330.07346    60745.984    60745.984   -1222.6104   -1222.6104 
Loop time of 196.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.544 hours/ns, 5.093 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    | 195.41     | 195.41     | 195.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15249    | 0.15249    | 0.15249    |   0.0 |  0.08
Output  | 0.00024906 | 0.00024906 | 0.00024906 |   0.0 |  0.00
Modify  | 0.70158    | 0.70158    | 0.70158    |   0.0 |  0.36
Other   |            | 0.09746    |            |       |  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:      310158.0 ave      310158 max      310158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310158
Ave neighs/atom = 77.539500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.605362186104, Press = 1.11628422697937
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22734.664   -22734.664   -22905.282   -22905.282    330.07346    330.07346    60745.984    60745.984   -1222.6104   -1222.6104 
   32000   -22738.361   -22738.361   -22910.752   -22910.752    333.50209    333.50209    60674.018    60674.018      1378.91      1378.91 
Loop time of 221.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.658 hours/ns, 4.505 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    | 220.87     | 220.87     | 220.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16709    | 0.16709    | 0.16709    |   0.0 |  0.08
Output  | 0.00018364 | 0.00018364 | 0.00018364 |   0.0 |  0.00
Modify  | 0.83043    | 0.83043    | 0.83043    |   0.0 |  0.37
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:      309920.0 ave      309920 max      309920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309920
Ave neighs/atom = 77.480000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.640275880539, Press = 0.551342006209551
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22738.361   -22738.361   -22910.752   -22910.752    333.50209    333.50209    60674.018    60674.018      1378.91      1378.91 
   33000   -22733.889   -22733.889   -22908.076   -22908.076    336.97781    336.97781    60743.682    60743.682   -1516.1147   -1516.1147 
Loop time of 198.677 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.188 hours/ns, 5.033 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    | 197.72     | 197.72     | 197.72     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.08
Output  | 0.00017903 | 0.00017903 | 0.00017903 |   0.0 |  0.00
Modify  | 0.70531    | 0.70531    | 0.70531    |   0.0 |  0.36
Other   |            | 0.0966     |            |       |  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:      310170.0 ave      310170 max      310170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310170
Ave neighs/atom = 77.542500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.674592842819, Press = -0.208342560996231
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22733.889   -22733.889   -22908.076   -22908.076    336.97781    336.97781    60743.682    60743.682   -1516.1147   -1516.1147 
   34000   -22738.846   -22738.846   -22909.727   -22909.727     330.5815     330.5815    60728.233    60728.233   -1078.8607   -1078.8607 
Loop time of 189.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.456 ns/day, 52.586 hours/ns, 5.282 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    | 188.41     | 188.41     | 188.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14753    | 0.14753    | 0.14753    |   0.0 |  0.08
Output  | 0.00018095 | 0.00018095 | 0.00018095 |   0.0 |  0.00
Modify  | 0.66001    | 0.66001    | 0.66001    |   0.0 |  0.35
Other   |            | 0.09352    |            |       |  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:      309984.0 ave      309984 max      309984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309984
Ave neighs/atom = 77.496000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.691419872458, Press = -0.908029037061323
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22738.846   -22738.846   -22909.727   -22909.727     330.5815     330.5815    60728.233    60728.233   -1078.8607   -1078.8607 
   35000   -22738.269   -22738.269   -22909.018   -22909.018    330.32554    330.32554    60668.428    60668.428    1762.4871    1762.4871 
Loop time of 189.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.456 ns/day, 52.632 hours/ns, 5.278 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.58     | 188.58     | 188.58     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14627    | 0.14627    | 0.14627    |   0.0 |  0.08
Output  | 0.00018343 | 0.00018343 | 0.00018343 |   0.0 |  0.00
Modify  | 0.66072    | 0.66072    | 0.66072    |   0.0 |  0.35
Other   |            | 0.09295    |            |       |  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:      310080.0 ave      310080 max      310080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310080
Ave neighs/atom = 77.520000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.671281732521, Press = 0.138997441894233
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22738.269   -22738.269   -22909.018   -22909.018    330.32554    330.32554    60668.428    60668.428    1762.4871    1762.4871 
   36000   -22734.199   -22734.199   -22905.703   -22905.703    331.78531    331.78531    60759.902    60759.902   -2032.8143   -2032.8143 
Loop time of 202.117 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.144 hours/ns, 4.948 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.14     | 201.14     | 201.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15257    | 0.15257    | 0.15257    |   0.0 |  0.08
Output  | 0.00017712 | 0.00017712 | 0.00017712 |   0.0 |  0.00
Modify  | 0.7253     | 0.7253     | 0.7253     |   0.0 |  0.36
Other   |            | 0.09772    |            |       |  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:      310188.0 ave      310188 max      310188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310188
Ave neighs/atom = 77.547000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.641636562429, Press = 1.33036386104694
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22734.199   -22734.199   -22905.703   -22905.703    331.78531    331.78531    60759.902    60759.902   -2032.8143   -2032.8143 
   37000   -22738.712   -22738.712   -22909.019   -22909.019    329.47166    329.47166    60736.506    60736.506   -1335.7095   -1335.7095 
Loop time of 221.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.412 hours/ns, 4.523 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.99     | 219.99     | 219.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16328    | 0.16328    | 0.16328    |   0.0 |  0.07
Output  | 0.00018044 | 0.00018044 | 0.00018044 |   0.0 |  0.00
Modify  | 0.82118    | 0.82118    | 0.82118    |   0.0 |  0.37
Other   |            | 0.1053     |            |       |  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:      309850.0 ave      309850 max      309850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309850
Ave neighs/atom = 77.462500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650362624031, Press = -1.57329612983529
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22738.712   -22738.712   -22909.019   -22909.019    329.47166    329.47166    60736.506    60736.506   -1335.7095   -1335.7095 
   38000   -22734.003   -22734.003   -22909.341   -22909.341    339.20287    339.20287    60672.293    60672.293    1665.6812    1665.6812 
Loop time of 209.607 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.224 hours/ns, 4.771 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.59     | 208.59     | 208.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15795    | 0.15795    | 0.15795    |   0.0 |  0.08
Output  | 0.00018168 | 0.00018168 | 0.00018168 |   0.0 |  0.00
Modify  | 0.75912    | 0.75912    | 0.75912    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  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:      310150.0 ave      310150 max      310150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310150
Ave neighs/atom = 77.537500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.630886791261, Press = 0.40741523600708
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.003   -22734.003   -22909.341   -22909.341    339.20287    339.20287    60672.293    60672.293    1665.6812    1665.6812 
   39000   -22739.355   -22739.355   -22909.804   -22909.804    329.74376    329.74376    60743.162    60743.162   -1850.6045   -1850.6045 
Loop time of 206.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.469 hours/ns, 4.833 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 205.87     | 205.87     | 205.87     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15875    | 0.15875    | 0.15875    |   0.0 |  0.08
Output  | 0.0001825  | 0.0001825  | 0.0001825  |   0.0 |  0.00
Modify  | 0.75982    | 0.75982    | 0.75982    |   0.0 |  0.37
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:      310094.0 ave      310094 max      310094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310094
Ave neighs/atom = 77.523500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.633497757393, Press = -0.381246285349248
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22739.355   -22739.355   -22909.804   -22909.804    329.74376    329.74376    60743.162    60743.162   -1850.6045   -1850.6045 
   40000   -22731.079   -22731.079   -22906.579   -22906.579    339.51655    339.51655    60651.795    60651.795    2948.0006    2948.0006 
Loop time of 223.419 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 62.061 hours/ns, 4.476 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    | 222.31     | 222.31     | 222.31     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1685     | 0.1685     | 0.1685     |   0.0 |  0.08
Output  | 0.00029105 | 0.00029105 | 0.00029105 |   0.0 |  0.00
Modify  | 0.83366    | 0.83366    | 0.83366    |   0.0 |  0.37
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:      310110.0 ave      310110 max      310110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310110
Ave neighs/atom = 77.527500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.653084807115, Press = 0.124540500254543
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22731.079   -22731.079   -22906.579   -22906.579    339.51655    339.51655    60651.795    60651.795    2948.0006    2948.0006 
   41000   -22736.525   -22736.525   -22905.876   -22905.876     327.6206     327.6206    60691.369    60691.369    1161.8587    1161.8587 
Loop time of 222.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.919 hours/ns, 4.486 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    | 221.8      | 221.8      | 221.8      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16875    | 0.16875    | 0.16875    |   0.0 |  0.08
Output  | 0.00055863 | 0.00055863 | 0.00055863 |   0.0 |  0.00
Modify  | 0.82982    | 0.82982    | 0.82982    |   0.0 |  0.37
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:      310100.0 ave      310100 max      310100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310100
Ave neighs/atom = 77.525000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.699602464906, Press = 0.850996629312802
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22736.525   -22736.525   -22905.876   -22905.876     327.6206     327.6206    60691.369    60691.369    1161.8587    1161.8587 
   42000   -22736.956   -22736.956   -22908.529   -22908.529    331.91947    331.91947    60775.997    60775.997   -3017.5298   -3017.5298 
Loop time of 192.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.449 ns/day, 53.418 hours/ns, 5.200 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    | 191.38     | 191.38     | 191.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1491     | 0.1491     | 0.1491     |   0.0 |  0.08
Output  | 0.00023381 | 0.00023381 | 0.00023381 |   0.0 |  0.00
Modify  | 0.68193    | 0.68193    | 0.68193    |   0.0 |  0.35
Other   |            | 0.09662    |            |       |  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:      309974.0 ave      309974 max      309974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309974
Ave neighs/atom = 77.493500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.668230304187, Press = 0.423498480777204
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22736.956   -22736.956   -22908.529   -22908.529    331.91947    331.91947    60775.997    60775.997   -3017.5298   -3017.5298 
   43000   -22740.697   -22740.697   -22909.376   -22909.376    326.32114    326.32114    60665.485    60665.485    1943.2158    1943.2158 
Loop time of 214.03 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.453 hours/ns, 4.672 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.97     | 212.97     | 212.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16367    | 0.16367    | 0.16367    |   0.0 |  0.08
Output  | 0.00017936 | 0.00017936 | 0.00017936 |   0.0 |  0.00
Modify  | 0.7888     | 0.7888     | 0.7888     |   0.0 |  0.37
Other   |            | 0.1041     |            |       |  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:      309932.0 ave      309932 max      309932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309932
Ave neighs/atom = 77.483000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.65080353759, Press = -1.31109759569707
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22740.697   -22740.697   -22909.376   -22909.376    326.32114    326.32114    60665.485    60665.485    1943.2158    1943.2158 
   44000   -22737.924   -22737.924   -22908.639   -22908.639    330.25894    330.25894    60670.266    60670.266    1775.8403    1775.8403 
Loop time of 212.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.407 ns/day, 58.971 hours/ns, 4.710 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    | 211.25     | 211.25     | 211.25     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16193    | 0.16193    | 0.16193    |   0.0 |  0.08
Output  | 0.00023112 | 0.00023112 | 0.00023112 |   0.0 |  0.00
Modify  | 0.77869    | 0.77869    | 0.77869    |   0.0 |  0.37
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:      310214.0 ave      310214 max      310214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310214
Ave neighs/atom = 77.553500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.684008344486, Press = 1.22134219794748
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22737.924   -22737.924   -22908.639   -22908.639    330.25894    330.25894    60670.266    60670.266    1775.8403    1775.8403 
   45000   -22733.433   -22733.433   -22906.659   -22906.659    335.11696    335.11696    60739.077    60739.077    -1044.604    -1044.604 
Loop time of 217.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.348 hours/ns, 4.603 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    | 216.18     | 216.18     | 216.18     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16242    | 0.16242    | 0.16242    |   0.0 |  0.07
Output  | 0.0002545  | 0.0002545  | 0.0002545  |   0.0 |  0.00
Modify  | 0.8019     | 0.8019     | 0.8019     |   0.0 |  0.37
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:      310180.0 ave      310180 max      310180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310180
Ave neighs/atom = 77.545000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.690301865369, Press = 0.477087717614421
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22733.433   -22733.433   -22906.659   -22906.659    335.11696    335.11696    60739.077    60739.077    -1044.604    -1044.604 
   46000   -22732.196   -22732.196   -22906.572   -22906.572    337.34329    337.34329    60728.542    60728.542   -372.58181   -372.58181 
Loop time of 209.647 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.235 hours/ns, 4.770 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    | 208.62     | 208.62     | 208.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15981    | 0.15981    | 0.15981    |   0.0 |  0.08
Output  | 0.00019074 | 0.00019074 | 0.00019074 |   0.0 |  0.00
Modify  | 0.76775    | 0.76775    | 0.76775    |   0.0 |  0.37
Other   |            | 0.1013     |            |       |  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:      310030.0 ave      310030 max      310030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310030
Ave neighs/atom = 77.507500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.716651403639, Press = -0.743210649435528
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22732.196   -22732.196   -22906.572   -22906.572    337.34329    337.34329    60728.542    60728.542   -372.58181   -372.58181 
   47000   -22739.527   -22739.527    -22912.77    -22912.77    335.15033    335.15033    60702.695    60702.695   -160.27273   -160.27273 
Loop time of 217.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.467 hours/ns, 4.594 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    | 216.6      | 216.6      | 216.6      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16512    | 0.16512    | 0.16512    |   0.0 |  0.08
Output  | 0.00018231 | 0.00018231 | 0.00018231 |   0.0 |  0.00
Modify  | 0.81275    | 0.81275    | 0.81275    |   0.0 |  0.37
Other   |            | 0.1052     |            |       |  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:      310096.0 ave      310096 max      310096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310096
Ave neighs/atom = 77.524000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.665769476566, Press = 0.772731258860522
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22739.527   -22739.527    -22912.77    -22912.77    335.15033    335.15033    60702.695    60702.695   -160.27273   -160.27273 
   48000   -22736.731   -22736.731   -22910.854   -22910.854    336.85372    336.85372      60677.3      60677.3    1348.1858    1348.1858 
Loop time of 218.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.746 hours/ns, 4.573 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    | 217.61     | 217.61     | 217.61     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16444    | 0.16444    | 0.16444    |   0.0 |  0.08
Output  | 0.00017821 | 0.00017821 | 0.00017821 |   0.0 |  0.00
Modify  | 0.80728    | 0.80728    | 0.80728    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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:      310204.0 ave      310204 max      310204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310204
Ave neighs/atom = 77.551000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.618643661615, Press = -0.596180949671167
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22736.731   -22736.731   -22910.854   -22910.854    336.85372    336.85372      60677.3      60677.3    1348.1858    1348.1858 
   49000   -22737.022   -22737.022   -22909.035   -22909.035    332.77091    332.77091    60636.717    60636.717    3386.4799    3386.4799 
Loop time of 198.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.081 hours/ns, 5.043 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.33     | 197.33     | 197.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.08
Output  | 0.0002295  | 0.0002295  | 0.0002295  |   0.0 |  0.00
Modify  | 0.71073    | 0.71073    | 0.71073    |   0.0 |  0.36
Other   |            | 0.09821    |            |       |  0.05

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

Total # of neighbors = 310348
Ave neighs/atom = 77.587000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.581049154972, Press = 0.0420093685361339
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22737.022   -22737.022   -22909.035   -22909.035    332.77091    332.77091    60636.717    60636.717    3386.4799    3386.4799 
   50000   -22738.678   -22738.678   -22910.496   -22910.496    332.39198    332.39198    60728.766    60728.766   -1140.3898   -1140.3898 
Loop time of 221.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.638 hours/ns, 4.507 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    | 220.79     | 220.79     | 220.79     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16705    | 0.16705    | 0.16705    |   0.0 |  0.08
Output  | 0.00023215 | 0.00023215 | 0.00023215 |   0.0 |  0.00
Modify  | 0.8295     | 0.8295     | 0.8295     |   0.0 |  0.37
Other   |            | 0.106      |            |       |  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:      310272.0 ave      310272 max      310272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310272
Ave neighs/atom = 77.568000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.578195365037, Press = 0.072147142878638
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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.678   -22738.678   -22910.496   -22910.496    332.39198    332.39198    60728.766    60728.766   -1140.3898   -1140.3898 
   51000   -22735.159   -22735.159   -22908.105   -22908.105    334.57504    334.57504    60698.163    60698.163    596.04719    596.04719 
Loop time of 207.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.742 hours/ns, 4.811 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    | 206.86     | 206.86     | 206.86     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15809    | 0.15809    | 0.15809    |   0.0 |  0.08
Output  | 0.00018066 | 0.00018066 | 0.00018066 |   0.0 |  0.00
Modify  | 0.75629    | 0.75629    | 0.75629    |   0.0 |  0.36
Other   |            | 0.09957    |            |       |  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:      310162.0 ave      310162 max      310162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310162
Ave neighs/atom = 77.540500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.549677549993, Press = 0.0173441094733194
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22735.159   -22735.159   -22908.105   -22908.105    334.57504    334.57504    60698.163    60698.163    596.04719    596.04719 
   52000   -22735.493   -22735.493   -22905.669   -22905.669    329.21791    329.21791    60734.469    60734.469    -877.5587    -877.5587 
Loop time of 221.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.468 hours/ns, 4.519 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    | 220.18     | 220.18     | 220.18     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16765    | 0.16765    | 0.16765    |   0.0 |  0.08
Output  | 0.00018131 | 0.00018131 | 0.00018131 |   0.0 |  0.00
Modify  | 0.82724    | 0.82724    | 0.82724    |   0.0 |  0.37
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:      310080.0 ave      310080 max      310080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310080
Ave neighs/atom = 77.520000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.590454085706, Press = -0.527997706431637
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22735.493   -22735.493   -22905.669   -22905.669    329.21791    329.21791    60734.469    60734.469    -877.5587    -877.5587 
   53000   -22736.807   -22736.807   -22907.161   -22907.161    329.56206    329.56206    60714.965    60714.965   -103.61632   -103.61632 
Loop time of 207.394 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.37     | 206.37     | 206.37     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1589     | 0.1589     | 0.1589     |   0.0 |  0.08
Output  | 0.00017616 | 0.00017616 | 0.00017616 |   0.0 |  0.00
Modify  | 0.75919    | 0.75919    | 0.75919    |   0.0 |  0.37
Other   |            | 0.1018     |            |       |  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:      309994.0 ave      309994 max      309994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309994
Ave neighs/atom = 77.498500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.591680661074, Press = -0.4811188205607
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22736.807   -22736.807   -22907.161   -22907.161    329.56206    329.56206    60714.965    60714.965   -103.61632   -103.61632 
   54000   -22736.557   -22736.557    -22908.64    -22908.64    332.90806    332.90806    60713.907    60713.907   -196.25007   -196.25007 
Loop time of 205.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.043 hours/ns, 4.870 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    | 204.35     | 204.35     | 204.35     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15546    | 0.15546    | 0.15546    |   0.0 |  0.08
Output  | 0.00018051 | 0.00018051 | 0.00018051 |   0.0 |  0.00
Modify  | 0.74585    | 0.74585    | 0.74585    |   0.0 |  0.36
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:      309978.0 ave      309978 max      309978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309978
Ave neighs/atom = 77.494500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.609570658688, Press = 1.22341928050774
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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   -22736.557   -22736.557    -22908.64    -22908.64    332.90806    332.90806    60713.907    60713.907   -196.25007   -196.25007 
   55000   -22735.291   -22735.291   -22908.623   -22908.623    335.32269    335.32269    60760.362    60760.362   -2438.9369   -2438.9369 
Loop time of 217.31 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.364 hours/ns, 4.602 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 216.24     | 216.24     | 216.24     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1616     | 0.1616     | 0.1616     |   0.0 |  0.07
Output  | 0.00018186 | 0.00018186 | 0.00018186 |   0.0 |  0.00
Modify  | 0.80502    | 0.80502    | 0.80502    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  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:      310260.0 ave      310260 max      310260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310260
Ave neighs/atom = 77.565000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.582538433533, Press = -1.44039107752904
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   55000   -22735.291   -22735.291   -22908.623   -22908.623    335.32269    335.32269    60760.362    60760.362   -2438.9369   -2438.9369 
   56000   -22739.561   -22739.561   -22911.489   -22911.489    332.60634    332.60634     60679.26     60679.26    891.06075    891.06075 
Loop time of 214.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.403 ns/day, 59.516 hours/ns, 4.667 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    | 213.19     | 213.19     | 213.19     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16312    | 0.16312    | 0.16312    |   0.0 |  0.08
Output  | 0.0001772  | 0.0001772  | 0.0001772  |   0.0 |  0.00
Modify  | 0.79445    | 0.79445    | 0.79445    |   0.0 |  0.37
Other   |            | 0.104      |            |       |  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:      309854.0 ave      309854 max      309854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309854
Ave neighs/atom = 77.463500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.583206165886, Press = 0.220622297933609
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   56000   -22739.561   -22739.561   -22911.489   -22911.489    332.60634    332.60634     60679.26     60679.26    891.06075    891.06075 
   57000   -22732.619   -22732.619   -22906.921   -22906.921    337.20081    337.20081    60726.202    60726.202   -570.63628   -570.63628 
Loop time of 210.944 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.596 hours/ns, 4.741 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.91     | 209.91     | 209.91     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15859    | 0.15859    | 0.15859    |   0.0 |  0.08
Output  | 0.00018166 | 0.00018166 | 0.00018166 |   0.0 |  0.00
Modify  | 0.76787    | 0.76787    | 0.76787    |   0.0 |  0.36
Other   |            | 0.1024     |            |       |  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:      310234.0 ave      310234 max      310234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310234
Ave neighs/atom = 77.558500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.599312419978, Press = 0.672844950965438
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   57000   -22732.619   -22732.619   -22906.921   -22906.921    337.20081    337.20081    60726.202    60726.202   -570.63628   -570.63628 
   58000    -22739.54    -22739.54   -22912.515   -22912.515    334.63131    334.63131    60674.894    60674.894    1112.4601    1112.4601 
Loop time of 189.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.456 ns/day, 52.632 hours/ns, 5.278 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    | 188.57     | 188.57     | 188.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14864    | 0.14864    | 0.14864    |   0.0 |  0.08
Output  | 0.00017667 | 0.00017667 | 0.00017667 |   0.0 |  0.00
Modify  | 0.66384    | 0.66384    | 0.66384    |   0.0 |  0.35
Other   |            | 0.09302    |            |       |  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:      310090.0 ave      310090 max      310090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310090
Ave neighs/atom = 77.522500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.598261704292, Press = -1.16048721578996
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   58000    -22739.54    -22739.54   -22912.515   -22912.515    334.63131    334.63131    60674.894    60674.894    1112.4601    1112.4601 
   59000   -22736.473   -22736.473   -22908.438   -22908.438    332.67746    332.67746     60670.42     60670.42    1808.7407    1808.7407 
Loop time of 189.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.562 hours/ns, 5.285 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.32     | 188.32     | 188.32     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15       | 0.15       | 0.15       |   0.0 |  0.08
Output  | 0.00018602 | 0.00018602 | 0.00018602 |   0.0 |  0.00
Modify  | 0.66417    | 0.66417    | 0.66417    |   0.0 |  0.35
Other   |            | 0.09316    |            |       |  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:      310340.0 ave      310340 max      310340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310340
Ave neighs/atom = 77.585000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.591832503297, Press = 0.299500974803695
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   59000   -22736.473   -22736.473   -22908.438   -22908.438    332.67746    332.67746     60670.42     60670.42    1808.7407    1808.7407 
   60000   -22741.104   -22741.104     -22910.1     -22910.1    326.93476    326.93476    60728.984    60728.984   -1097.6474   -1097.6474 
Loop time of 219.735 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.038 hours/ns, 4.551 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    | 218.65     | 218.65     | 218.65     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16809    | 0.16809    | 0.16809    |   0.0 |  0.08
Output  | 0.00029176 | 0.00029176 | 0.00029176 |   0.0 |  0.00
Modify  | 0.81571    | 0.81571    | 0.81571    |   0.0 |  0.37
Other   |            | 0.105      |            |       |  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:      310088.0 ave      310088 max      310088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310088
Ave neighs/atom = 77.522000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.540099762573, Press = 0.0995847851919477
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   60000   -22741.104   -22741.104     -22910.1     -22910.1    326.93476    326.93476    60728.984    60728.984   -1097.6474   -1097.6474 
   61000   -22735.127   -22735.127   -22910.414   -22910.414    339.10381    339.10381    60692.502    60692.502     534.3005     534.3005 
Loop time of 222.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.799 hours/ns, 4.495 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    | 221.37     | 221.37     | 221.37     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16829    | 0.16829    | 0.16829    |   0.0 |  0.08
Output  | 0.00023165 | 0.00023165 | 0.00023165 |   0.0 |  0.00
Modify  | 0.83234    | 0.83234    | 0.83234    |   0.0 |  0.37
Other   |            | 0.1054     |            |       |  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:      310076.0 ave      310076 max      310076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310076
Ave neighs/atom = 77.519000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523490620557, Press = -0.0686438075969063
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   61000   -22735.127   -22735.127   -22910.414   -22910.414    339.10381    339.10381    60692.502    60692.502     534.3005     534.3005 
   62000   -22744.944   -22744.944   -22916.485   -22916.485    331.85879    331.85879    60688.148    60688.148   -149.80983   -149.80983 
Loop time of 222.384 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.773 hours/ns, 4.497 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    | 221.27     | 221.27     | 221.27     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16802    | 0.16802    | 0.16802    |   0.0 |  0.08
Output  | 0.00017872 | 0.00017872 | 0.00017872 |   0.0 |  0.00
Modify  | 0.83487    | 0.83487    | 0.83487    |   0.0 |  0.38
Other   |            | 0.1066     |            |       |  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:      310190.0 ave      310190 max      310190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310190
Ave neighs/atom = 77.547500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.495699899501, Press = 0.307218201073896
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   62000   -22744.944   -22744.944   -22916.485   -22916.485    331.85879    331.85879    60688.148    60688.148   -149.80983   -149.80983 
   63000    -22732.83    -22732.83   -22906.533   -22906.533    336.03933    336.03933    60704.392    60704.392    417.96915    417.96915 
Loop time of 218.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.730 hours/ns, 4.574 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    | 217.54     | 217.54     | 217.54     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1661     | 0.1661     | 0.1661     |   0.0 |  0.08
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.81158    | 0.81158    | 0.81158    |   0.0 |  0.37
Other   |            | 0.1047     |            |       |  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:      310326.0 ave      310326 max      310326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310326
Ave neighs/atom = 77.581500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474838677281, Press = -0.778393880339222
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   63000    -22732.83    -22732.83   -22906.533   -22906.533    336.03933    336.03933    60704.392    60704.392    417.96915    417.96915 
   64000   -22736.015   -22736.015    -22910.53    -22910.53    337.61182    337.61182    60664.583    60664.583     1865.338     1865.338 
Loop time of 223.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.156 hours/ns, 4.469 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.65     | 222.65     | 222.65     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16935    | 0.16935    | 0.16935    |   0.0 |  0.08
Output  | 0.00017929 | 0.00017929 | 0.00017929 |   0.0 |  0.00
Modify  | 0.83687    | 0.83687    | 0.83687    |   0.0 |  0.37
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:      310098.0 ave      310098 max      310098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310098
Ave neighs/atom = 77.524500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483340135589, Press = 0.48063489373909
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   64000   -22736.015   -22736.015    -22910.53    -22910.53    337.61182    337.61182    60664.583    60664.583     1865.338     1865.338 
   65000   -22736.025   -22736.025   -22912.729   -22912.729    341.84597    341.84597    60730.311    60730.311    -1467.969    -1467.969 
Loop time of 216.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.265 hours/ns, 4.609 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.88     | 215.88     | 215.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16442    | 0.16442    | 0.16442    |   0.0 |  0.08
Output  | 0.00018404 | 0.00018404 | 0.00018404 |   0.0 |  0.00
Modify  | 0.80766    | 0.80766    | 0.80766    |   0.0 |  0.37
Other   |            | 0.1052     |            |       |  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:      310232.0 ave      310232 max      310232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310232
Ave neighs/atom = 77.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.508833455051, Press = 0.10451481480991
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   65000   -22736.025   -22736.025   -22912.729   -22912.729    341.84597    341.84597    60730.311    60730.311    -1467.969    -1467.969 
   66000   -22734.224   -22734.224   -22907.383   -22907.383    334.98669    334.98669     60717.08     60717.08   -181.00673   -181.00673 
Loop time of 212.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.065 hours/ns, 4.703 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    | 211.59     | 211.59     | 211.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16236    | 0.16236    | 0.16236    |   0.0 |  0.08
Output  | 0.00018116 | 0.00018116 | 0.00018116 |   0.0 |  0.00
Modify  | 0.78261    | 0.78261    | 0.78261    |   0.0 |  0.37
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:      310232.0 ave      310232 max      310232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310232
Ave neighs/atom = 77.558000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.491212738913, Press = -0.539407986377715
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   66000   -22734.224   -22734.224   -22907.383   -22907.383    334.98669    334.98669     60717.08     60717.08   -181.00673   -181.00673 
   67000   -22740.641   -22740.641   -22908.152   -22908.152    324.05981    324.05981    60711.006    60711.006   -155.11973   -155.11973 
Loop time of 218.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.714 hours/ns, 4.575 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    | 217.49     | 217.49     | 217.49     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16638    | 0.16638    | 0.16638    |   0.0 |  0.08
Output  | 0.00068065 | 0.00068065 | 0.00068065 |   0.0 |  0.00
Modify  | 0.81104    | 0.81104    | 0.81104    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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:      310088.0 ave      310088 max      310088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310088
Ave neighs/atom = 77.522000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.450129173353, Press = 0.158052691363724
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   67000   -22740.641   -22740.641   -22908.152   -22908.152    324.05981    324.05981    60711.006    60711.006   -155.11973   -155.11973 
   68000   -22734.879   -22734.879   -22910.184   -22910.184    339.14055    339.14055    60737.426    60737.426   -1477.9736   -1477.9736 
Loop time of 224.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.272 hours/ns, 4.461 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    | 223.07     | 223.07     | 223.07     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17004    | 0.17004    | 0.17004    |   0.0 |  0.08
Output  | 0.00022608 | 0.00022608 | 0.00022608 |   0.0 |  0.00
Modify  | 0.83646    | 0.83646    | 0.83646    |   0.0 |  0.37
Other   |            | 0.1066     |            |       |  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:      310212.0 ave      310212 max      310212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310212
Ave neighs/atom = 77.553000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.431639941939, Press = -0.287515471163996
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   68000   -22734.879   -22734.879   -22910.184   -22910.184    339.14055    339.14055    60737.426    60737.426   -1477.9736   -1477.9736 
   69000   -22737.782   -22737.782   -22907.498   -22907.498    328.32692    328.32692     60687.79     60687.79     1015.833     1015.833 
Loop time of 208.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.414 ns/day, 57.979 hours/ns, 4.791 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.69     | 207.69     | 207.69     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.164      | 0.164      | 0.164      |   0.0 |  0.08
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.77052    | 0.77052    | 0.77052    |   0.0 |  0.37
Other   |            | 0.1026     |            |       |  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:      310090.0 ave      310090 max      310090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310090
Ave neighs/atom = 77.522500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.404469648238, Press = 0.111955314282036
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   69000   -22737.782   -22737.782   -22907.498   -22907.498    328.32692    328.32692     60687.79     60687.79     1015.833     1015.833 
   70000   -22732.428   -22732.428    -22904.09    -22904.09    332.09159    332.09159    60748.512    60748.512   -1186.3338   -1186.3338 
Loop time of 203.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.488 hours/ns, 4.917 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.37     | 202.37     | 202.37     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15756    | 0.15756    | 0.15756    |   0.0 |  0.08
Output  | 0.00018346 | 0.00018346 | 0.00018346 |   0.0 |  0.00
Modify  | 0.73269    | 0.73269    | 0.73269    |   0.0 |  0.36
Other   |            | 0.09886    |            |       |  0.05

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

Total # of neighbors = 310090
Ave neighs/atom = 77.522500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.408074268921, Press = -0.286653343594235
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   70000   -22732.428   -22732.428    -22904.09    -22904.09    332.09159    332.09159    60748.512    60748.512   -1186.3338   -1186.3338 
   71000    -22736.94    -22736.94   -22907.939   -22907.939    330.81065    330.81065    60723.344    60723.344   -612.15118   -612.15118 
Loop time of 219.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.881 hours/ns, 4.563 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    | 218.09     | 218.09     | 218.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16518    | 0.16518    | 0.16518    |   0.0 |  0.08
Output  | 0.00022415 | 0.00022415 | 0.00022415 |   0.0 |  0.00
Modify  | 0.80889    | 0.80889    | 0.80889    |   0.0 |  0.37
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:      309978.0 ave      309978 max      309978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309978
Ave neighs/atom = 77.494500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.42609687932, Press = -0.834808951866578
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   71000    -22736.94    -22736.94   -22907.939   -22907.939    330.81065    330.81065    60723.344    60723.344   -612.15118   -612.15118 
   72000    -22740.01    -22740.01   -22910.142   -22910.142    329.13061    329.13061    60665.728    60665.728     1834.167     1834.167 
Loop time of 193.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.447 ns/day, 53.652 hours/ns, 5.177 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    | 192.22     | 192.22     | 192.22     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15147    | 0.15147    | 0.15147    |   0.0 |  0.08
Output  | 0.00022993 | 0.00022993 | 0.00022993 |   0.0 |  0.00
Modify  | 0.68298    | 0.68298    | 0.68298    |   0.0 |  0.35
Other   |            | 0.09506    |            |       |  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:      310112.0 ave      310112 max      310112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310112
Ave neighs/atom = 77.528000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425480879494, Press = 0.116768221990351
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   72000    -22740.01    -22740.01   -22910.142   -22910.142    329.13061    329.13061    60665.728    60665.728     1834.167     1834.167 
   73000    -22738.88    -22738.88   -22910.896   -22910.896    332.77658    332.77658    60737.066    60737.066   -1561.2738   -1561.2738 
Loop time of 215.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.737 hours/ns, 4.650 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    | 213.99     | 213.99     | 213.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16281    | 0.16281    | 0.16281    |   0.0 |  0.08
Output  | 0.00018305 | 0.00018305 | 0.00018305 |   0.0 |  0.00
Modify  | 0.79079    | 0.79079    | 0.79079    |   0.0 |  0.37
Other   |            | 0.1039     |            |       |  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:      310222.0 ave      310222 max      310222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310222
Ave neighs/atom = 77.555500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.430928178894, Press = -0.0964931662729042
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   73000    -22738.88    -22738.88   -22910.896   -22910.896    332.77658    332.77658    60737.066    60737.066   -1561.2738   -1561.2738 
   74000   -22743.322   -22743.322   -22913.726   -22913.726    329.65743    329.65743    60629.619    60629.619    3077.0134    3077.0134 
Loop time of 203.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.422 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.12     | 202.12     | 202.12     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15625    | 0.15625    | 0.15625    |   0.0 |  0.08
Output  | 0.00018812 | 0.00018812 | 0.00018812 |   0.0 |  0.00
Modify  | 0.73746    | 0.73746    | 0.73746    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  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:      310164.0 ave      310164 max      310164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310164
Ave neighs/atom = 77.541000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392485613651, Press = -0.3998136314702
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   74000   -22743.322   -22743.322   -22913.726   -22913.726    329.65743    329.65743    60629.619    60629.619    3077.0134    3077.0134 
   75000   -22736.548   -22736.548   -22906.106   -22906.106    328.02192    328.02192    60689.336    60689.336    1103.6187    1103.6187 
Loop time of 189.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.712 hours/ns, 5.270 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    | 188.85     | 188.85     | 188.85     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14941    | 0.14941    | 0.14941    |   0.0 |  0.08
Output  | 0.00018317 | 0.00018317 | 0.00018317 |   0.0 |  0.00
Modify  | 0.66663    | 0.66663    | 0.66663    |   0.0 |  0.35
Other   |            | 0.09363    |            |       |  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:      310392.0 ave      310392 max      310392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310392
Ave neighs/atom = 77.598000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.374788843347, Press = 0.765253092859711
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   75000   -22736.548   -22736.548   -22906.106   -22906.106    328.02192    328.02192    60689.336    60689.336    1103.6187    1103.6187 
   76000   -22740.504   -22740.504   -22910.603   -22910.603    329.06859    329.06859    60709.273    60709.273   -306.28319   -306.28319 
Loop time of 199.331 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.370 hours/ns, 5.017 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    | 198.36     | 198.36     | 198.36     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.155      | 0.155      | 0.155      |   0.0 |  0.08
Output  | 0.00022635 | 0.00022635 | 0.00022635 |   0.0 |  0.00
Modify  | 0.71715    | 0.71715    | 0.71715    |   0.0 |  0.36
Other   |            | 0.09671    |            |       |  0.05

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

Total # of neighbors = 309922
Ave neighs/atom = 77.480500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.374112501271, Press = -0.0922916915175164
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   76000   -22740.504   -22740.504   -22910.603   -22910.603    329.06859    329.06859    60709.273    60709.273   -306.28319   -306.28319 
   77000   -22735.425   -22735.425   -22910.134   -22910.134    337.98621    337.98621    60707.406    60707.406    -70.24633    -70.24633 
Loop time of 205.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.969 hours/ns, 4.876 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.09     | 204.09     | 204.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15806    | 0.15806    | 0.15806    |   0.0 |  0.08
Output  | 0.00017851 | 0.00017851 | 0.00017851 |   0.0 |  0.00
Modify  | 0.74294    | 0.74294    | 0.74294    |   0.0 |  0.36
Other   |            | 0.09973    |            |       |  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:      310146.0 ave      310146 max      310146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310146
Ave neighs/atom = 77.536500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.377051130092, Press = -0.367898763025907
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   77000   -22735.425   -22735.425   -22910.134   -22910.134    337.98621    337.98621    60707.406    60707.406    -70.24633    -70.24633 
   78000   -22740.676   -22740.676   -22909.785   -22909.785    327.15436    327.15436    60673.517    60673.517    1494.2888    1494.2888 
Loop time of 189.965 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.768 hours/ns, 5.264 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 189.05     | 189.05     | 189.05     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.08
Output  | 0.00022461 | 0.00022461 | 0.00022461 |   0.0 |  0.00
Modify  | 0.66755    | 0.66755    | 0.66755    |   0.0 |  0.35
Other   |            | 0.09467    |            |       |  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:      310110.0 ave      310110 max      310110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310110
Ave neighs/atom = 77.527500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.373794578318, Press = 0.0702864262190959
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   78000   -22740.676   -22740.676   -22909.785   -22909.785    327.15436    327.15436    60673.517    60673.517    1494.2888    1494.2888 
   79000   -22736.405   -22736.405   -22909.867   -22909.867    335.57455    335.57455     60729.84     60729.84   -1000.3317   -1000.3317 
Loop time of 213.061 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.184 hours/ns, 4.693 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    | 212        | 212        | 212        |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16351    | 0.16351    | 0.16351    |   0.0 |  0.08
Output  | 0.00018185 | 0.00018185 | 0.00018185 |   0.0 |  0.00
Modify  | 0.78819    | 0.78819    | 0.78819    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  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:      310208.0 ave      310208 max      310208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310208
Ave neighs/atom = 77.552000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.372679655464, Press = -0.352877799135241
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   79000   -22736.405   -22736.405   -22909.867   -22909.867    335.57455    335.57455     60729.84     60729.84   -1000.3317   -1000.3317 
   80000    -22736.45    -22736.45   -22911.214   -22911.214    338.09227    338.09227    60676.377    60676.377    1215.8366    1215.8366 
Loop time of 189.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.743 hours/ns, 5.267 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    | 188.96     | 188.96     | 188.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15228    | 0.15228    | 0.15228    |   0.0 |  0.08
Output  | 0.00018327 | 0.00018327 | 0.00018327 |   0.0 |  0.00
Modify  | 0.66732    | 0.66732    | 0.66732    |   0.0 |  0.35
Other   |            | 0.09409    |            |       |  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:      310114.0 ave      310114 max      310114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310114
Ave neighs/atom = 77.528500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.373026800799, Press = 0.211699257578682
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   80000    -22736.45    -22736.45   -22911.214   -22911.214    338.09227    338.09227    60676.377    60676.377    1215.8366    1215.8366 
   81000   -22731.665   -22731.665   -22908.861   -22908.861    342.79682    342.79682    60735.808    60735.808   -1186.3427   -1186.3427 
Loop time of 189.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.456 ns/day, 52.641 hours/ns, 5.277 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    | 188.59     | 188.59     | 188.59     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.08
Output  | 0.00022836 | 0.00022836 | 0.00022836 |   0.0 |  0.00
Modify  | 0.66898    | 0.66898    | 0.66898    |   0.0 |  0.35
Other   |            | 0.09368    |            |       |  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:      310128.0 ave      310128 max      310128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310128
Ave neighs/atom = 77.532000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40283293046, Press = 0.230222788421911
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   81000   -22731.665   -22731.665   -22908.861   -22908.861    342.79682    342.79682    60735.808    60735.808   -1186.3427   -1186.3427 
   82000   -22738.247   -22738.247   -22908.468   -22908.468    329.30498    329.30498    60718.427    60718.427   -431.93934   -431.93934 
Loop time of 189.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.551 hours/ns, 5.286 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 188.27     | 188.27     | 188.27     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15186    | 0.15186    | 0.15186    |   0.0 |  0.08
Output  | 0.00018116 | 0.00018116 | 0.00018116 |   0.0 |  0.00
Modify  | 0.66739    | 0.66739    | 0.66739    |   0.0 |  0.35
Other   |            | 0.09472    |            |       |  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:      309962.0 ave      309962 max      309962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 309962
Ave neighs/atom = 77.490500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.381219778966, Press = -0.39867528430947
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   82000   -22738.247   -22738.247   -22908.468   -22908.468    329.30498    329.30498    60718.427    60718.427   -431.93934   -431.93934 
   83000   -22734.533   -22734.533   -22908.168   -22908.168     335.9091     335.9091    60629.184    60629.184    3756.1335    3756.1335 
Loop time of 200.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.777 hours/ns, 4.980 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.82     | 199.82     | 199.82     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1559     | 0.1559     | 0.1559     |   0.0 |  0.08
Output  | 0.00022432 | 0.00022432 | 0.00022432 |   0.0 |  0.00
Modify  | 0.72466    | 0.72466    | 0.72466    |   0.0 |  0.36
Other   |            | 0.09891    |            |       |  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:      310096.0 ave      310096 max      310096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310096
Ave neighs/atom = 77.524000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.36819520007, Press = 0.404621577890207
next a
jump SELF top
variable a loop 2000
run 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      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 
   83000   -22734.533   -22734.533   -22908.168   -22908.168     335.9091     335.9091    60629.184    60629.184    3756.1335    3756.1335 
   84000   -22736.656   -22736.656    -22908.73    -22908.73    332.88878    332.88878     60742.81     60742.81   -1632.8423   -1632.8423 
Loop time of 199.07 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.297 hours/ns, 5.023 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    | 198.1      | 198.1      | 198.1      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1552     | 0.1552     | 0.1552     |   0.0 |  0.08
Output  | 0.00018071 | 0.00018071 | 0.00018071 |   0.0 |  0.00
Modify  | 0.71863    | 0.71863    | 0.71863    |   0.0 |  0.36
Other   |            | 0.09935    |            |       |  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:      310100.0 ave      310100 max      310100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310100
Ave neighs/atom = 77.525000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
60708.6299189502

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0