# 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.620386697351933*${_u_distance}
variable latticeconst_converted equal 3.620386697351933*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62038669735193
Lattice spacing in x,y,z = 3.6203867 3.6203867 3.6203867
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.203867 36.203867 36.203867)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.203867 36.203867 36.203867)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -14018.806   -14018.806       -14160       -14160       273.15       273.15    47453.132    47453.132    3178.1465    3178.1465 
    1000   -13867.477   -13867.477   -14015.596   -14015.596    286.54657    286.54657    48100.673    48100.673   -985.32485   -985.32485 
Loop time of 77.89 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.636 hours/ns, 12.839 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.487     | 77.487     | 77.487     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051992   | 0.051992   | 0.051992   |   0.0 |  0.07
Output  | 0.00039767 | 0.00039767 | 0.00039767 |   0.0 |  0.00
Modify  | 0.30024    | 0.30024    | 0.30024    |   0.0 |  0.39
Other   |            | 0.05033    |            |       |  0.06

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

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13867.477   -13867.477   -14015.596   -14015.596    286.54657    286.54657    48100.673    48100.673   -985.32485   -985.32485 
    2000    -13878.63    -13878.63   -14023.447   -14023.447    280.15879    280.15879    48083.009    48083.009   -1053.2934   -1053.2934 
Loop time of 78.6587 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.098 ns/day, 21.850 hours/ns, 12.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.283     | 78.283     | 78.283     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048737   | 0.048737   | 0.048737   |   0.0 |  0.06
Output  | 0.00014411 | 0.00014411 | 0.00014411 |   0.0 |  0.00
Modify  | 0.28119    | 0.28119    | 0.28119    |   0.0 |  0.36
Other   |            | 0.04538    |            |       |  0.06

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:      311066.0 ave      311066 max      311066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311066
Ave neighs/atom = 77.766500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13878.63    -13878.63   -14023.447   -14023.447    280.15879    280.15879    48083.009    48083.009   -1053.2934   -1053.2934 
    3000   -13873.307   -13873.307    -14020.37    -14020.37     284.5028     284.5028    48084.045    48084.045   -689.95849   -689.95849 
Loop time of 78.749 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.875 hours/ns, 12.699 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    | 78.37      | 78.37      | 78.37      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048894   | 0.048894   | 0.048894   |   0.0 |  0.06
Output  | 0.00014151 | 0.00014151 | 0.00014151 |   0.0 |  0.00
Modify  | 0.28351    | 0.28351    | 0.28351    |   0.0 |  0.36
Other   |            | 0.04658    |            |       |  0.06

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:      311320.0 ave      311320 max      311320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311320
Ave neighs/atom = 77.830000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.307   -13873.307    -14020.37    -14020.37     284.5028     284.5028    48084.045    48084.045   -689.95849   -689.95849 
    4000   -13877.172   -13877.172   -14019.442   -14019.442    275.23023    275.23023    48080.378    48080.378   -623.18251   -623.18251 
Loop time of 78.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.868 hours/ns, 12.702 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    | 78.346     | 78.346     | 78.346     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048449   | 0.048449   | 0.048449   |   0.0 |  0.06
Output  | 0.00015081 | 0.00015081 | 0.00015081 |   0.0 |  0.00
Modify  | 0.28383    | 0.28383    | 0.28383    |   0.0 |  0.36
Other   |            | 0.04796    |            |       |  0.06

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:      311182.0 ave      311182 max      311182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311182
Ave neighs/atom = 77.795500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.172   -13877.172   -14019.442   -14019.442    275.23023    275.23023    48080.378    48080.378   -623.18251   -623.18251 
    5000   -13876.405   -13876.405   -14018.659   -14018.659    275.20101    275.20101    48063.104    48063.104   -67.571818   -67.571818 
Loop time of 78.4714 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.101 ns/day, 21.798 hours/ns, 12.744 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.095     | 78.095     | 78.095     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048749   | 0.048749   | 0.048749   |   0.0 |  0.06
Output  | 0.00011076 | 0.00011076 | 0.00011076 |   0.0 |  0.00
Modify  | 0.28269    | 0.28269    | 0.28269    |   0.0 |  0.36
Other   |            | 0.04495    |            |       |  0.06

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:      311142.0 ave      311142 max      311142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311142
Ave neighs/atom = 77.785500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 276.870955284138, Press = 407.138521464965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.405   -13876.405   -14018.659   -14018.659    275.20101    275.20101    48063.104    48063.104   -67.571818   -67.571818 
    6000   -13873.514   -13873.514     -14017.5     -14017.5    278.54998    278.54998    48013.811    48013.811    1644.2046    1644.2046 
Loop time of 78.5593 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.822 hours/ns, 12.729 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    | 78.172     | 78.172     | 78.172     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048573   | 0.048573   | 0.048573   |   0.0 |  0.06
Output  | 0.0001132  | 0.0001132  | 0.0001132  |   0.0 |  0.00
Modify  | 0.29302    | 0.29302    | 0.29302    |   0.0 |  0.37
Other   |            | 0.04561    |            |       |  0.06

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:      311144.0 ave      311144 max      311144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311144
Ave neighs/atom = 77.786000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.725241789811, Press = 24.4674579356956
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.514   -13873.514     -14017.5     -14017.5    278.54998    278.54998    48013.811    48013.811    1644.2046    1644.2046 
    7000   -13879.643   -13879.643   -14019.619   -14019.619    270.79245    270.79245    48058.833    48058.833   -40.843002   -40.843002 
Loop time of 78.6338 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.843 hours/ns, 12.717 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    | 78.246     | 78.246     | 78.246     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049165   | 0.049165   | 0.049165   |   0.0 |  0.06
Output  | 0.00024478 | 0.00024478 | 0.00024478 |   0.0 |  0.00
Modify  | 0.29286    | 0.29286    | 0.29286    |   0.0 |  0.37
Other   |            | 0.04603    |            |       |  0.06

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:      311330.0 ave      311330 max      311330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311330
Ave neighs/atom = 77.832500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.060676124233, Press = -17.6838450625872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13879.643   -13879.643   -14019.619   -14019.619    270.79245    270.79245    48058.833    48058.833   -40.843002   -40.843002 
    8000   -13873.815   -13873.815   -14015.912   -14015.912    274.89735    274.89735    48118.887    48118.887   -1359.3339   -1359.3339 
Loop time of 78.7877 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.885 hours/ns, 12.692 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    | 78.394     | 78.394     | 78.394     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049957   | 0.049957   | 0.049957   |   0.0 |  0.06
Output  | 0.00010236 | 0.00010236 | 0.00010236 |   0.0 |  0.00
Modify  | 0.29522    | 0.29522    | 0.29522    |   0.0 |  0.37
Other   |            | 0.04829    |            |       |  0.06

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:      311292.0 ave      311292 max      311292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311292
Ave neighs/atom = 77.823000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.310967011477, Press = 3.95166622612121
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.815   -13873.815   -14015.912   -14015.912    274.89735    274.89735    48118.887    48118.887   -1359.3339   -1359.3339 
    9000   -13874.651   -13874.651   -14016.305   -14016.305    274.03891    274.03891    48085.293    48085.293   -495.52909   -495.52909 
Loop time of 78.1099 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.106 ns/day, 21.697 hours/ns, 12.802 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    | 77.733     | 77.733     | 77.733     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047452   | 0.047452   | 0.047452   |   0.0 |  0.06
Output  | 0.00017833 | 0.00017833 | 0.00017833 |   0.0 |  0.00
Modify  | 0.2858     | 0.2858     | 0.2858     |   0.0 |  0.37
Other   |            | 0.04392    |            |       |  0.06

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:      311046.0 ave      311046 max      311046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311046
Ave neighs/atom = 77.761500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.345131787683, Press = 10.5501502299288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.651   -13874.651   -14016.305   -14016.305    274.03891    274.03891    48085.293    48085.293   -495.52909   -495.52909 
   10000    -13877.98    -13877.98   -14017.972   -14017.972    270.82277    270.82277    48047.054    48047.054    454.67497    454.67497 
Loop time of 78.2108 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.105 ns/day, 21.725 hours/ns, 12.786 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    | 77.834     | 77.834     | 77.834     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047629   | 0.047629   | 0.047629   |   0.0 |  0.06
Output  | 0.00010256 | 0.00010256 | 0.00010256 |   0.0 |  0.00
Modify  | 0.28508    | 0.28508    | 0.28508    |   0.0 |  0.36
Other   |            | 0.04378    |            |       |  0.06

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:      311104.0 ave      311104 max      311104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311104
Ave neighs/atom = 77.776000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.716289674585, Press = 5.25388786213978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13877.98    -13877.98   -14017.972   -14017.972    270.82277    270.82277    48047.054    48047.054    454.67497    454.67497 
   11000   -13877.798   -13877.798   -14021.193   -14021.193     277.4079     277.4079    48085.773    48085.773   -909.89157   -909.89157 
Loop time of 78.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.105 ns/day, 21.729 hours/ns, 12.784 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    | 77.845     | 77.845     | 77.845     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047681   | 0.047681   | 0.047681   |   0.0 |  0.06
Output  | 0.00010225 | 0.00010225 | 0.00010225 |   0.0 |  0.00
Modify  | 0.28601    | 0.28601    | 0.28601    |   0.0 |  0.37
Other   |            | 0.04433    |            |       |  0.06

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:      311226.0 ave      311226 max      311226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311226
Ave neighs/atom = 77.806500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.611109849476, Press = 0.357800736465856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.798   -13877.798   -14021.193   -14021.193     277.4079     277.4079    48085.773    48085.773   -909.89157   -909.89157 
   12000   -13874.398   -13874.398   -14016.754   -14016.754    275.39593    275.39593    48126.205    48126.205   -1617.6454   -1617.6454 
Loop time of 78.1104 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.106 ns/day, 21.697 hours/ns, 12.802 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    | 77.733     | 77.733     | 77.733     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047608   | 0.047608   | 0.047608   |   0.0 |  0.06
Output  | 0.00010326 | 0.00010326 | 0.00010326 |   0.0 |  0.00
Modify  | 0.28522    | 0.28522    | 0.28522    |   0.0 |  0.37
Other   |            | 0.04411    |            |       |  0.06

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:      311318.0 ave      311318 max      311318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311318
Ave neighs/atom = 77.829500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.607502826316, Press = 6.94994293438114
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.398   -13874.398   -14016.754   -14016.754    275.39593    275.39593    48126.205    48126.205   -1617.6454   -1617.6454 
   13000   -13876.277   -13876.277   -14016.754   -14016.754    271.76195    271.76195    48032.221    48032.221    1046.2711    1046.2711 
Loop time of 78.1849 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.105 ns/day, 21.718 hours/ns, 12.790 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    | 77.804     | 77.804     | 77.804     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04835    | 0.04835    | 0.04835    |   0.0 |  0.06
Output  | 0.00020462 | 0.00020462 | 0.00020462 |   0.0 |  0.00
Modify  | 0.28723    | 0.28723    | 0.28723    |   0.0 |  0.37
Other   |            | 0.04497    |            |       |  0.06

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:      311194.0 ave      311194 max      311194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311194
Ave neighs/atom = 77.798500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.513234372119, Press = 9.62088815607858
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.277   -13876.277   -14016.754   -14016.754    271.76195    271.76195    48032.221    48032.221    1046.2711    1046.2711 
   14000   -13872.562   -13872.562   -14015.248   -14015.248    276.03496    276.03496    48035.788    48035.788     1206.043     1206.043 
Loop time of 78.1952 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.105 ns/day, 21.721 hours/ns, 12.789 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    | 77.815     | 77.815     | 77.815     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047886   | 0.047886   | 0.047886   |   0.0 |  0.06
Output  | 9.9863e-05 | 9.9863e-05 | 9.9863e-05 |   0.0 |  0.00
Modify  | 0.28723    | 0.28723    | 0.28723    |   0.0 |  0.37
Other   |            | 0.04495    |            |       |  0.06

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:      311306.0 ave      311306 max      311306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311306
Ave neighs/atom = 77.826500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.642381451042, Press = 2.23105708034423
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13872.562   -13872.562   -14015.248   -14015.248    276.03496    276.03496    48035.788    48035.788     1206.043     1206.043 
   15000   -13875.919   -13875.919   -14019.217   -14019.217    277.22046    277.22046    48058.991    48058.991    115.59231    115.59231 
Loop time of 78.1205 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.106 ns/day, 21.700 hours/ns, 12.801 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    | 77.738     | 77.738     | 77.738     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048181   | 0.048181   | 0.048181   |   0.0 |  0.06
Output  | 0.00010238 | 0.00010238 | 0.00010238 |   0.0 |  0.00
Modify  | 0.28841    | 0.28841    | 0.28841    |   0.0 |  0.37
Other   |            | 0.04566    |            |       |  0.06

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:      311280.0 ave      311280 max      311280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311280
Ave neighs/atom = 77.820000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.634287458702, Press = 1.05417826429462
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.919   -13875.919   -14019.217   -14019.217    277.22046    277.22046    48058.991    48058.991    115.59231    115.59231 
   16000   -13875.239   -13875.239   -14018.031   -14018.031    276.24009    276.24009    48086.622    48086.622   -582.36153   -582.36153 
Loop time of 78.6527 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.848 hours/ns, 12.714 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    | 78.258     | 78.258     | 78.258     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050053   | 0.050053   | 0.050053   |   0.0 |  0.06
Output  | 0.0002254  | 0.0002254  | 0.0002254  |   0.0 |  0.00
Modify  | 0.29522    | 0.29522    | 0.29522    |   0.0 |  0.38
Other   |            | 0.04932    |            |       |  0.06

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:      311272.0 ave      311272 max      311272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311272
Ave neighs/atom = 77.818000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.758221731397, Press = 1.2558397451479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.239   -13875.239   -14018.031   -14018.031    276.24009    276.24009    48086.622    48086.622   -582.36153   -582.36153 
   17000   -13876.028   -13876.028   -14017.666   -14017.666    274.00943    274.00943     48085.25     48085.25    -530.5724    -530.5724 
Loop time of 78.548 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.819 hours/ns, 12.731 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    | 78.154     | 78.154     | 78.154     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050051   | 0.050051   | 0.050051   |   0.0 |  0.06
Output  | 0.00022936 | 0.00022936 | 0.00022936 |   0.0 |  0.00
Modify  | 0.29483    | 0.29483    | 0.29483    |   0.0 |  0.38
Other   |            | 0.04855    |            |       |  0.06

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:      311176.0 ave      311176 max      311176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311176
Ave neighs/atom = 77.794000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.799621640856, Press = 2.70925678864341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.028   -13876.028   -14017.666   -14017.666    274.00943    274.00943     48085.25     48085.25    -530.5724    -530.5724 
   18000   -13880.368   -13880.368   -14021.638   -14021.638    273.29721    273.29721    48066.858    48066.858   -387.33729   -387.33729 
Loop time of 78.6168 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.838 hours/ns, 12.720 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    | 78.22      | 78.22      | 78.22      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050404   | 0.050404   | 0.050404   |   0.0 |  0.06
Output  | 0.00022978 | 0.00022978 | 0.00022978 |   0.0 |  0.00
Modify  | 0.29673    | 0.29673    | 0.29673    |   0.0 |  0.38
Other   |            | 0.0494     |            |       |  0.06

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:      311274.0 ave      311274 max      311274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311274
Ave neighs/atom = 77.818500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.799212124167, Press = 3.48293113630963
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13880.368   -13880.368   -14021.638   -14021.638    273.29721    273.29721    48066.858    48066.858   -387.33729   -387.33729 
   19000   -13874.957   -13874.957   -14018.875   -14018.875    278.41873    278.41873    48022.517    48022.517    1325.0806    1325.0806 
Loop time of 78.7696 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.097 ns/day, 21.880 hours/ns, 12.695 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    | 78.371     | 78.371     | 78.371     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051184   | 0.051184   | 0.051184   |   0.0 |  0.06
Output  | 0.00012815 | 0.00012815 | 0.00012815 |   0.0 |  0.00
Modify  | 0.29735    | 0.29735    | 0.29735    |   0.0 |  0.38
Other   |            | 0.05038    |            |       |  0.06

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:      311286.0 ave      311286 max      311286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311286
Ave neighs/atom = 77.821500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.677940195371, Press = 2.55762104184258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.957   -13874.957   -14018.875   -14018.875    278.41873    278.41873    48022.517    48022.517    1325.0806    1325.0806 
   20000   -13875.996   -13875.996    -14015.73    -14015.73    270.32624    270.32624    48036.759    48036.759     994.9998     994.9998 
Loop time of 78.6002 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.833 hours/ns, 12.723 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    | 78.204     | 78.204     | 78.204     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049943   | 0.049943   | 0.049943   |   0.0 |  0.06
Output  | 0.0001037  | 0.0001037  | 0.0001037  |   0.0 |  0.00
Modify  | 0.29567    | 0.29567    | 0.29567    |   0.0 |  0.38
Other   |            | 0.05013    |            |       |  0.06

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:      311384.0 ave      311384 max      311384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311384
Ave neighs/atom = 77.846000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.580759098543, Press = -1.89324571193144
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.996   -13875.996    -14015.73    -14015.73    270.32624    270.32624    48036.759    48036.759     994.9998     994.9998 
   21000   -13876.179   -13876.179   -14016.332   -14016.332    271.13726    271.13726    48117.955    48117.955   -1435.4075   -1435.4075 
Loop time of 78.5941 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.832 hours/ns, 12.724 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    | 78.198     | 78.198     | 78.198     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050573   | 0.050573   | 0.050573   |   0.0 |  0.06
Output  | 0.00018953 | 0.00018953 | 0.00018953 |   0.0 |  0.00
Modify  | 0.29522    | 0.29522    | 0.29522    |   0.0 |  0.38
Other   |            | 0.05009    |            |       |  0.06

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:      311206.0 ave      311206 max      311206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311206
Ave neighs/atom = 77.801500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.577027765072, Press = 0.0930694617166389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.179   -13876.179   -14016.332   -14016.332    271.13726    271.13726    48117.955    48117.955   -1435.4075   -1435.4075 
   22000   -13870.958   -13870.958   -14013.826   -14013.826    276.38886    276.38886    48094.053    48094.053   -435.44396   -435.44396 
Loop time of 78.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.098 ns/day, 21.865 hours/ns, 12.704 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    | 78.316     | 78.316     | 78.316     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050357   | 0.050357   | 0.050357   |   0.0 |  0.06
Output  | 0.00010649 | 0.00010649 | 0.00010649 |   0.0 |  0.00
Modify  | 0.29691    | 0.29691    | 0.29691    |   0.0 |  0.38
Other   |            | 0.05085    |            |       |  0.06

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:      311248.0 ave      311248 max      311248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311248
Ave neighs/atom = 77.812000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.577405541838, Press = 2.43826944228512
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13870.958   -13870.958   -14013.826   -14013.826    276.38886    276.38886    48094.053    48094.053   -435.44396   -435.44396 
   23000    -13876.96    -13876.96   -14018.789   -14018.789      274.377      274.377    48044.347    48044.347    529.47707    529.47707 
Loop time of 78.6253 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.099 ns/day, 21.840 hours/ns, 12.719 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    | 78.231     | 78.231     | 78.231     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050256   | 0.050256   | 0.050256   |   0.0 |  0.06
Output  | 0.00010791 | 0.00010791 | 0.00010791 |   0.0 |  0.00
Modify  | 0.29435    | 0.29435    | 0.29435    |   0.0 |  0.37
Other   |            | 0.04958    |            |       |  0.06

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:      311040.0 ave      311040 max      311040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311040
Ave neighs/atom = 77.760000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.640244862472, Press = 2.54779040596863
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13876.96    -13876.96   -14018.789   -14018.789      274.377      274.377    48044.347    48044.347    529.47707    529.47707 
   24000   -13871.403   -13871.403   -14013.101   -14013.101    274.12417    274.12417     48050.36     48050.36    911.90339    911.90339 
Loop time of 78.9757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.094 ns/day, 21.938 hours/ns, 12.662 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    | 78.574     | 78.574     | 78.574     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051485   | 0.051485   | 0.051485   |   0.0 |  0.07
Output  | 0.00010776 | 0.00010776 | 0.00010776 |   0.0 |  0.00
Modify  | 0.29836    | 0.29836    | 0.29836    |   0.0 |  0.38
Other   |            | 0.05144    |            |       |  0.07

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:      311208.0 ave      311208 max      311208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311208
Ave neighs/atom = 77.802000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.679753363567, Press = 0.712156079026875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13871.403   -13871.403   -14013.101   -14013.101    274.12417    274.12417     48050.36     48050.36    911.90339    911.90339 
   25000   -13876.992   -13876.992   -14017.869   -14017.869    272.53476    272.53476    48075.387    48075.387   -258.66717   -258.66717 
Loop time of 78.5261 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.100 ns/day, 21.813 hours/ns, 12.735 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    | 78.133     | 78.133     | 78.133     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049956   | 0.049956   | 0.049956   |   0.0 |  0.06
Output  | 0.00010874 | 0.00010874 | 0.00010874 |   0.0 |  0.00
Modify  | 0.2938     | 0.2938     | 0.2938     |   0.0 |  0.37
Other   |            | 0.04954    |            |       |  0.06

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:      311184.0 ave      311184 max      311184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311184
Ave neighs/atom = 77.796000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.699007536976, Press = 0.305829084204725
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.992   -13876.992   -14017.869   -14017.869    272.53476    272.53476    48075.387    48075.387   -258.66717   -258.66717 
   26000   -13873.897   -13873.897   -14015.748   -14015.748     274.4205     274.4205    48089.174    48089.174   -505.13819   -505.13819 
Loop time of 78.0118 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.670 hours/ns, 12.819 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    | 77.637     | 77.637     | 77.637     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047106   | 0.047106   | 0.047106   |   0.0 |  0.06
Output  | 0.00010468 | 0.00010468 | 0.00010468 |   0.0 |  0.00
Modify  | 0.28381    | 0.28381    | 0.28381    |   0.0 |  0.36
Other   |            | 0.04393    |            |       |  0.06

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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.665262377335, Press = 1.07765954139739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.897   -13873.897   -14015.748   -14015.748     274.4205     274.4205    48089.174    48089.174   -505.13819   -505.13819 
   27000   -13876.042   -13876.042   -14015.285   -14015.285    269.37476    269.37476    48041.922    48041.922    857.91891    857.91891 
Loop time of 77.9957 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.665 hours/ns, 12.821 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    | 77.62      | 77.62      | 77.62      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046936   | 0.046936   | 0.046936   |   0.0 |  0.06
Output  | 0.0001054  | 0.0001054  | 0.0001054  |   0.0 |  0.00
Modify  | 0.28437    | 0.28437    | 0.28437    |   0.0 |  0.36
Other   |            | 0.04401    |            |       |  0.06

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:      311142.0 ave      311142 max      311142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311142
Ave neighs/atom = 77.785500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.710784522765, Press = 2.0515329875127
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.042   -13876.042   -14015.285   -14015.285    269.37476    269.37476    48041.922    48041.922    857.91891    857.91891 
   28000   -13873.077   -13873.077    -14016.41    -14016.41    277.28768    277.28768    48012.251    48012.251    1719.9325    1719.9325 
Loop time of 78.0103 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.670 hours/ns, 12.819 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    | 77.636     | 77.636     | 77.636     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047235   | 0.047235   | 0.047235   |   0.0 |  0.06
Output  | 0.00010978 | 0.00010978 | 0.00010978 |   0.0 |  0.00
Modify  | 0.28308    | 0.28308    | 0.28308    |   0.0 |  0.36
Other   |            | 0.04399    |            |       |  0.06

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:      311156.0 ave      311156 max      311156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311156
Ave neighs/atom = 77.789000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.688513692949, Press = -0.189446257508537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.077   -13873.077    -14016.41    -14016.41    277.28768    277.28768    48012.251    48012.251    1719.9325    1719.9325 
   29000   -13876.141   -13876.141   -14014.039   -14014.039    266.77312    266.77312    48102.635    48102.635   -852.25403   -852.25403 
Loop time of 78.0317 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.107 ns/day, 21.675 hours/ns, 12.815 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    | 77.657     | 77.657     | 77.657     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048193   | 0.048193   | 0.048193   |   0.0 |  0.06
Output  | 0.00010288 | 0.00010288 | 0.00010288 |   0.0 |  0.00
Modify  | 0.28307    | 0.28307    | 0.28307    |   0.0 |  0.36
Other   |            | 0.0438     |            |       |  0.06

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:      311220.0 ave      311220 max      311220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311220
Ave neighs/atom = 77.805000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.677809786709, Press = -0.917298107523442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.141   -13876.141   -14014.039   -14014.039    266.77312    266.77312    48102.635    48102.635   -852.25403   -852.25403 
   30000   -13877.602   -13877.602   -14018.294   -14018.294    272.17751    272.17751    48098.517    48098.517    -1090.652    -1090.652 
Loop time of 77.9602 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.656 hours/ns, 12.827 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    | 77.587     | 77.587     | 77.587     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047595   | 0.047595   | 0.047595   |   0.0 |  0.06
Output  | 0.00012058 | 0.00012058 | 0.00012058 |   0.0 |  0.00
Modify  | 0.28214    | 0.28214    | 0.28214    |   0.0 |  0.36
Other   |            | 0.04345    |            |       |  0.06

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:      311002.0 ave      311002 max      311002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311002
Ave neighs/atom = 77.750500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.705640128393, Press = 1.38911355991302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.602   -13877.602   -14018.294   -14018.294    272.17751    272.17751    48098.517    48098.517    -1090.652    -1090.652 
   31000   -13875.298   -13875.298   -14016.261   -14016.261    272.70358    272.70358    48079.857    48079.857   -282.52595   -282.52595 
Loop time of 77.9648 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.657 hours/ns, 12.826 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    | 77.592     | 77.592     | 77.592     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046772   | 0.046772   | 0.046772   |   0.0 |  0.06
Output  | 0.00010668 | 0.00010668 | 0.00010668 |   0.0 |  0.00
Modify  | 0.28227    | 0.28227    | 0.28227    |   0.0 |  0.36
Other   |            | 0.04355    |            |       |  0.06

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:      311218.0 ave      311218 max      311218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311218
Ave neighs/atom = 77.804500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.691068591506, Press = 1.60107094458486
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.298   -13875.298   -14016.261   -14016.261    272.70358    272.70358    48079.857    48079.857   -282.52595   -282.52595 
   32000    -13878.44    -13878.44   -14018.407   -14018.407    270.77541    270.77541    48068.316    48068.316    -135.4306    -135.4306 
Loop time of 77.9361 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.649 hours/ns, 12.831 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    | 77.563     | 77.563     | 77.563     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046959   | 0.046959   | 0.046959   |   0.0 |  0.06
Output  | 0.00010485 | 0.00010485 | 0.00010485 |   0.0 |  0.00
Modify  | 0.28279    | 0.28279    | 0.28279    |   0.0 |  0.36
Other   |            | 0.04362    |            |       |  0.06

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:      311184.0 ave      311184 max      311184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311184
Ave neighs/atom = 77.796000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.681513345282, Press = 1.25136566447466
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13878.44    -13878.44   -14018.407   -14018.407    270.77541    270.77541    48068.316    48068.316    -135.4306    -135.4306 
   33000   -13871.908   -13871.908   -14016.368   -14016.368     279.4677     279.4677    48049.746    48049.746    673.46296    673.46296 
Loop time of 78.0595 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.107 ns/day, 21.683 hours/ns, 12.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    | 77.686     | 77.686     | 77.686     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047168   | 0.047168   | 0.047168   |   0.0 |  0.06
Output  | 0.00010264 | 0.00010264 | 0.00010264 |   0.0 |  0.00
Modify  | 0.28291    | 0.28291    | 0.28291    |   0.0 |  0.36
Other   |            | 0.04358    |            |       |  0.06

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:      311182.0 ave      311182 max      311182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311182
Ave neighs/atom = 77.795500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.708269089457, Press = 1.18723193692296
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13871.908   -13871.908   -14016.368   -14016.368     279.4677     279.4677    48049.746    48049.746    673.46296    673.46296 
   34000   -13877.652   -13877.652   -14018.706   -14018.706    272.87922    272.87922    48055.985    48055.985    131.93739    131.93739 
Loop time of 77.9231 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.645 hours/ns, 12.833 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    | 77.55      | 77.55      | 77.55      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047135   | 0.047135   | 0.047135   |   0.0 |  0.06
Output  | 0.00010394 | 0.00010394 | 0.00010394 |   0.0 |  0.00
Modify  | 0.2826     | 0.2826     | 0.2826     |   0.0 |  0.36
Other   |            | 0.04335    |            |       |  0.06

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:      311170.0 ave      311170 max      311170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311170
Ave neighs/atom = 77.792500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.7008737912, Press = -0.401547157882205
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.652   -13877.652   -14018.706   -14018.706    272.87922    272.87922    48055.985    48055.985    131.93739    131.93739 
   35000   -13876.648   -13876.648   -14019.154   -14019.154    275.68669    275.68669    48155.414    48155.414   -2680.0557   -2680.0557 
Loop time of 78.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.108 ns/day, 21.670 hours/ns, 12.818 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    | 77.639     | 77.639     | 77.639     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047151   | 0.047151   | 0.047151   |   0.0 |  0.06
Output  | 0.00010857 | 0.00010857 | 0.00010857 |   0.0 |  0.00
Modify  | 0.2831     | 0.2831     | 0.2831     |   0.0 |  0.36
Other   |            | 0.04341    |            |       |  0.06

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:      311216.0 ave      311216 max      311216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311216
Ave neighs/atom = 77.804000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.688466841433, Press = -0.0675475375350538
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.648   -13876.648   -14019.154   -14019.154    275.68669    275.68669    48155.414    48155.414   -2680.0557   -2680.0557 
   36000   -13874.082   -13874.082   -14016.953   -14016.953    276.39332    276.39332    48095.195    48095.195   -779.55677   -779.55677 
Loop time of 77.9134 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.643 hours/ns, 12.835 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    | 77.54      | 77.54      | 77.54      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047528   | 0.047528   | 0.047528   |   0.0 |  0.06
Output  | 0.00010245 | 0.00010245 | 0.00010245 |   0.0 |  0.00
Modify  | 0.28281    | 0.28281    | 0.28281    |   0.0 |  0.36
Other   |            | 0.04331    |            |       |  0.06

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:      311184.0 ave      311184 max      311184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311184
Ave neighs/atom = 77.796000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.65463513652, Press = 2.67854153555488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.082   -13874.082   -14016.953   -14016.953    276.39332    276.39332    48095.195    48095.195   -779.55677   -779.55677 
   37000   -13878.576   -13878.576   -14020.141   -14020.141    273.86679    273.86679    48044.617    48044.617    434.07869    434.07869 
Loop time of 77.9037 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.640 hours/ns, 12.836 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    | 77.531     | 77.531     | 77.531     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047007   | 0.047007   | 0.047007   |   0.0 |  0.06
Output  | 0.00011828 | 0.00011828 | 0.00011828 |   0.0 |  0.00
Modify  | 0.28267    | 0.28267    | 0.28267    |   0.0 |  0.36
Other   |            | 0.04334    |            |       |  0.06

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:      311122.0 ave      311122 max      311122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311122
Ave neighs/atom = 77.780500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.604177176744, Press = 0.883134503243534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13878.576   -13878.576   -14020.141   -14020.141    273.86679    273.86679    48044.617    48044.617    434.07869    434.07869 
   38000   -13872.876   -13872.876   -14015.164   -14015.164    275.26588    275.26588    48075.781    48075.781    63.784017    63.784017 
Loop time of 77.9279 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.647 hours/ns, 12.832 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.555     | 77.555     | 77.555     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047011   | 0.047011   | 0.047011   |   0.0 |  0.06
Output  | 0.00010264 | 0.00010264 | 0.00010264 |   0.0 |  0.00
Modify  | 0.28232    | 0.28232    | 0.28232    |   0.0 |  0.36
Other   |            | 0.04337    |            |       |  0.06

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:      311282.0 ave      311282 max      311282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311282
Ave neighs/atom = 77.820500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.545907544068, Press = 0.0980513787030211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13872.876   -13872.876   -14015.164   -14015.164    275.26588    275.26588    48075.781    48075.781    63.784017    63.784017 
   39000   -13878.436   -13878.436   -14018.467   -14018.467    270.89867    270.89867    48092.385    48092.385   -804.47148   -804.47148 
Loop time of 77.8569 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.627 hours/ns, 12.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.486     | 77.486     | 77.486     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046751   | 0.046751   | 0.046751   |   0.0 |  0.06
Output  | 0.0001039  | 0.0001039  | 0.0001039  |   0.0 |  0.00
Modify  | 0.28082    | 0.28082    | 0.28082    |   0.0 |  0.36
Other   |            | 0.04294    |            |       |  0.06

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:      311190.0 ave      311190 max      311190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311190
Ave neighs/atom = 77.797500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.526080689704, Press = 0.130464065594002
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13878.436   -13878.436   -14018.467   -14018.467    270.89867    270.89867    48092.385    48092.385   -804.47148   -804.47148 
   40000   -13874.124   -13874.124   -14013.831   -14013.831    270.27303    270.27303     48118.26     48118.26   -1196.7405   -1196.7405 
Loop time of 77.7374 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.594 hours/ns, 12.864 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    | 77.369     | 77.369     | 77.369     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046644   | 0.046644   | 0.046644   |   0.0 |  0.06
Output  | 0.00010303 | 0.00010303 | 0.00010303 |   0.0 |  0.00
Modify  | 0.27931    | 0.27931    | 0.27931    |   0.0 |  0.36
Other   |            | 0.04257    |            |       |  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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.54776818435, Press = 1.27994204242573
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.124   -13874.124   -14013.831   -14013.831    270.27303    270.27303     48118.26     48118.26   -1196.7405   -1196.7405 
   41000   -13877.567   -13877.567   -14019.283   -14019.283    274.15917    274.15917    48032.836    48032.836    832.85691    832.85691 
Loop time of 77.7189 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.589 hours/ns, 12.867 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    | 77.35      | 77.35      | 77.35      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04658    | 0.04658    | 0.04658    |   0.0 |  0.06
Output  | 0.0001073  | 0.0001073  | 0.0001073  |   0.0 |  0.00
Modify  | 0.27921    | 0.27921    | 0.27921    |   0.0 |  0.36
Other   |            | 0.04287    |            |       |  0.06

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:      311140.0 ave      311140 max      311140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311140
Ave neighs/atom = 77.785000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.577830298317, Press = 2.019172787662
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.567   -13877.567   -14019.283   -14019.283    274.15917    274.15917    48032.836    48032.836    832.85691    832.85691 
   42000   -13872.044   -13872.044   -14013.351   -14013.351    273.36942    273.36942    48041.239    48041.239    1160.4363    1160.4363 
Loop time of 77.8132 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.615 hours/ns, 12.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.445     | 77.445     | 77.445     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046386   | 0.046386   | 0.046386   |   0.0 |  0.06
Output  | 0.00010459 | 0.00010459 | 0.00010459 |   0.0 |  0.00
Modify  | 0.27887    | 0.27887    | 0.27887    |   0.0 |  0.36
Other   |            | 0.04245    |            |       |  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:      311254.0 ave      311254 max      311254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311254
Ave neighs/atom = 77.813500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.590701924504, Press = 0.0944447650620341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13872.044   -13872.044   -14013.351   -14013.351    273.36942    273.36942    48041.239    48041.239    1160.4363    1160.4363 
   43000   -13877.249   -13877.249    -14017.27    -14017.27    270.88036    270.88036    48087.977    48087.977    -606.6827    -606.6827 
Loop time of 77.7562 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.599 hours/ns, 12.861 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    | 77.388     | 77.388     | 77.388     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046537   | 0.046537   | 0.046537   |   0.0 |  0.06
Output  | 0.00010562 | 0.00010562 | 0.00010562 |   0.0 |  0.00
Modify  | 0.27907    | 0.27907    | 0.27907    |   0.0 |  0.36
Other   |            | 0.04239    |            |       |  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:      311072.0 ave      311072 max      311072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311072
Ave neighs/atom = 77.768000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.608613422854, Press = -0.0994746614493528
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.249   -13877.249    -14017.27    -14017.27    270.88036    270.88036    48087.977    48087.977    -606.6827    -606.6827 
   44000   -13869.297   -13869.297    -14013.62    -14013.62    279.20344    279.20344    48151.447    48151.447   -1961.7133   -1961.7133 
Loop time of 77.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.611 hours/ns, 12.854 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    | 77.431     | 77.431     | 77.431     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046506   | 0.046506   | 0.046506   |   0.0 |  0.06
Output  | 0.00010584 | 0.00010584 | 0.00010584 |   0.0 |  0.00
Modify  | 0.27876    | 0.27876    | 0.27876    |   0.0 |  0.36
Other   |            | 0.04244    |            |       |  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:      311290.0 ave      311290 max      311290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311290
Ave neighs/atom = 77.822500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.616551598055, Press = 1.04964909856258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13869.297   -13869.297    -14013.62    -14013.62    279.20344    279.20344    48151.447    48151.447   -1961.7133   -1961.7133 
   45000   -13875.676   -13875.676   -14015.475   -14015.475    270.44916    270.44916      48056.8      48056.8    434.51934    434.51934 
Loop time of 77.8221 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.617 hours/ns, 12.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.455     | 77.455     | 77.455     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046593   | 0.046593   | 0.046593   |   0.0 |  0.06
Output  | 0.00010655 | 0.00010655 | 0.00010655 |   0.0 |  0.00
Modify  | 0.27827    | 0.27827    | 0.27827    |   0.0 |  0.36
Other   |            | 0.0422     |            |       |  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:      311098.0 ave      311098 max      311098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311098
Ave neighs/atom = 77.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.653771134898, Press = 2.48047953636901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.676   -13875.676   -14015.475   -14015.475    270.44916    270.44916      48056.8      48056.8    434.51934    434.51934 
   46000   -13877.206   -13877.206    -14018.26    -14018.26    272.87799    272.87799    48028.659    48028.659    980.14733    980.14733 
Loop time of 77.7253 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.590 hours/ns, 12.866 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    | 77.359     | 77.359     | 77.359     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046402   | 0.046402   | 0.046402   |   0.0 |  0.06
Output  | 0.00010266 | 0.00010266 | 0.00010266 |   0.0 |  0.00
Modify  | 0.27752    | 0.27752    | 0.27752    |   0.0 |  0.36
Other   |            | 0.04202    |            |       |  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:      311190.0 ave      311190 max      311190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311190
Ave neighs/atom = 77.797500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.626220519404, Press = 0.869918680322194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.206   -13877.206    -14018.26    -14018.26    272.87799    272.87799    48028.659    48028.659    980.14733    980.14733 
   47000    -13873.89    -13873.89    -14016.48    -14016.48    275.85047    275.85047    48069.008    48069.008     76.14266     76.14266 
Loop time of 77.7949 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.610 hours/ns, 12.854 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    | 77.429     | 77.429     | 77.429     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046386   | 0.046386   | 0.046386   |   0.0 |  0.06
Output  | 0.00010488 | 0.00010488 | 0.00010488 |   0.0 |  0.00
Modify  | 0.27767    | 0.27767    | 0.27767    |   0.0 |  0.36
Other   |            | 0.04202    |            |       |  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:      311290.0 ave      311290 max      311290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311290
Ave neighs/atom = 77.822500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.608092361502, Press = 0.192553565582522
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13873.89    -13873.89    -14016.48    -14016.48    275.85047    275.85047    48069.008    48069.008     76.14266     76.14266 
   48000   -13879.673   -13879.673   -14018.975   -14018.975    269.49036    269.49036    48068.879    48068.879   -277.58765   -277.58765 
Loop time of 77.7814 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.606 hours/ns, 12.857 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    | 77.416     | 77.416     | 77.416     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046414   | 0.046414   | 0.046414   |   0.0 |  0.06
Output  | 0.0001052  | 0.0001052  | 0.0001052  |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.04198    |            |       |  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:      311198.0 ave      311198 max      311198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311198
Ave neighs/atom = 77.799500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.572282045759, Press = 0.733247809342254
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13879.673   -13879.673   -14018.975   -14018.975    269.49036    269.49036    48068.879    48068.879   -277.58765   -277.58765 
   49000    -13875.64    -13875.64   -14016.508   -14016.508    272.51799    272.51799    48066.154    48066.154    124.17179    124.17179 
Loop time of 77.7659 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.602 hours/ns, 12.859 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    | 77.4       | 77.4       | 77.4       |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046368   | 0.046368   | 0.046368   |   0.0 |  0.06
Output  | 9.8355e-05 | 9.8355e-05 | 9.8355e-05 |   0.0 |  0.00
Modify  | 0.27776    | 0.27776    | 0.27776    |   0.0 |  0.36
Other   |            | 0.04202    |            |       |  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:      311214.0 ave      311214 max      311214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311214
Ave neighs/atom = 77.803500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.544622624848, Press = 0.758743290613085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13875.64    -13875.64   -14016.508   -14016.508    272.51799    272.51799    48066.154    48066.154    124.17179    124.17179 
   50000    -13871.75    -13871.75   -14014.754   -14014.754    276.65021    276.65021    48056.977    48056.977    558.04251    558.04251 
Loop time of 77.7146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.587 hours/ns, 12.868 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    | 77.349     | 77.349     | 77.349     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046258   | 0.046258   | 0.046258   |   0.0 |  0.06
Output  | 0.00010705 | 0.00010705 | 0.00010705 |   0.0 |  0.00
Modify  | 0.27758    | 0.27758    | 0.27758    |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311276.0 ave      311276 max      311276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311276
Ave neighs/atom = 77.819000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.520167832129, Press = 0.707985329333631
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13871.75    -13871.75   -14014.754   -14014.754    276.65021    276.65021    48056.977    48056.977    558.04251    558.04251 
   51000   -13874.978   -13874.978    -14017.15    -14017.15    275.04059    275.04059    48040.687    48040.687    832.76737    832.76737 
Loop time of 77.8031 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.612 hours/ns, 12.853 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    | 77.437     | 77.437     | 77.437     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046322   | 0.046322   | 0.046322   |   0.0 |  0.06
Output  | 0.0001042  | 0.0001042  | 0.0001042  |   0.0 |  0.00
Modify  | 0.27744    | 0.27744    | 0.27744    |   0.0 |  0.36
Other   |            | 0.04191    |            |       |  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:      311192.0 ave      311192 max      311192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311192
Ave neighs/atom = 77.798000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.551568918754, Press = 0.224638393274983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.978   -13874.978    -14017.15    -14017.15    275.04059    275.04059    48040.687    48040.687    832.76737    832.76737 
   52000   -13873.845   -13873.845   -14015.389   -14015.389    273.82633    273.82633    48084.484    48084.484   -266.27237   -266.27237 
Loop time of 77.7915 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.609 hours/ns, 12.855 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    | 77.426     | 77.426     | 77.426     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046271   | 0.046271   | 0.046271   |   0.0 |  0.06
Output  | 0.00010471 | 0.00010471 | 0.00010471 |   0.0 |  0.00
Modify  | 0.27742    | 0.27742    | 0.27742    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311228.0 ave      311228 max      311228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311228
Ave neighs/atom = 77.807000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.556780939708, Press = -0.558487299739425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.845   -13873.845   -14015.389   -14015.389    273.82633    273.82633    48084.484    48084.484   -266.27237   -266.27237 
   53000    -13878.65    -13878.65   -14018.101   -14018.101    269.77686    269.77686    48127.186    48127.186   -1838.9512   -1838.9512 
Loop time of 77.7741 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.604 hours/ns, 12.858 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    | 77.408     | 77.408     | 77.408     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046361   | 0.046361   | 0.046361   |   0.0 |  0.06
Output  | 0.00010444 | 0.00010444 | 0.00010444 |   0.0 |  0.00
Modify  | 0.27763    | 0.27763    | 0.27763    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311170.0 ave      311170 max      311170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311170
Ave neighs/atom = 77.792500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.55349563988, Press = 0.47576450893021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13878.65    -13878.65   -14018.101   -14018.101    269.77686    269.77686    48127.186    48127.186   -1838.9512   -1838.9512 
   54000   -13875.605   -13875.605   -14017.928   -14017.928    275.33438    275.33438    48058.103    48058.103    130.09998    130.09998 
Loop time of 77.7167 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.588 hours/ns, 12.867 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    | 77.35      | 77.35      | 77.35      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046815   | 0.046815   | 0.046815   |   0.0 |  0.06
Output  | 0.00010999 | 0.00010999 | 0.00010999 |   0.0 |  0.00
Modify  | 0.27748    | 0.27748    | 0.27748    |   0.0 |  0.36
Other   |            | 0.042      |            |       |  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:      311164.0 ave      311164 max      311164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311164
Ave neighs/atom = 77.791000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.574030615995, Press = 1.40422753731806
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.605   -13875.605   -14017.928   -14017.928    275.33438    275.33438    48058.103    48058.103    130.09998    130.09998 
   55000   -13874.035   -13874.035   -14019.199   -14019.199    280.82895    280.82895    48037.145    48037.145      775.623      775.623 
Loop time of 77.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.588 hours/ns, 12.868 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    | 77.349     | 77.349     | 77.349     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046336   | 0.046336   | 0.046336   |   0.0 |  0.06
Output  | 0.00010628 | 0.00010628 | 0.00010628 |   0.0 |  0.00
Modify  | 0.27773    | 0.27773    | 0.27773    |   0.0 |  0.36
Other   |            | 0.04208    |            |       |  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:      311098.0 ave      311098 max      311098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311098
Ave neighs/atom = 77.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.57154998672, Press = 0.287163999572777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.035   -13874.035   -14019.199   -14019.199    280.82895    280.82895    48037.145    48037.145      775.623      775.623 
   56000   -13877.836   -13877.836   -14020.094   -14020.094    275.20727    275.20727    48062.676    48062.676   -66.701689   -66.701689 
Loop time of 77.7147 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.587 hours/ns, 12.868 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    | 77.348     | 77.348     | 77.348     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046915   | 0.046915   | 0.046915   |   0.0 |  0.06
Output  | 0.00010203 | 0.00010203 | 0.00010203 |   0.0 |  0.00
Modify  | 0.27743    | 0.27743    | 0.27743    |   0.0 |  0.36
Other   |            | 0.04195    |            |       |  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:      311298.0 ave      311298 max      311298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311298
Ave neighs/atom = 77.824500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.582069934277, Press = -0.0142810574949291
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.836   -13877.836   -14020.094   -14020.094    275.20727    275.20727    48062.676    48062.676   -66.701689   -66.701689 
   57000   -13876.977   -13876.977   -14016.765   -14016.765    270.42879    270.42879    48102.432    48102.432    -944.6894    -944.6894 
Loop time of 77.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.596 hours/ns, 12.862 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    | 77.38      | 77.38      | 77.38      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046361   | 0.046361   | 0.046361   |   0.0 |  0.06
Output  | 0.00010425 | 0.00010425 | 0.00010425 |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311288.0 ave      311288 max      311288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311288
Ave neighs/atom = 77.822000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.598164942283, Press = 0.164296810818442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.977   -13876.977   -14016.765   -14016.765    270.42879    270.42879    48102.432    48102.432    -944.6894    -944.6894 
   58000   -13875.877   -13875.877   -14017.509   -14017.509    273.99573    273.99573    48085.342    48085.342    -553.8456    -553.8456 
Loop time of 77.7017 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.584 hours/ns, 12.870 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    | 77.336     | 77.336     | 77.336     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046469   | 0.046469   | 0.046469   |   0.0 |  0.06
Output  | 0.00010335 | 0.00010335 | 0.00010335 |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311168.0 ave      311168 max      311168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311168
Ave neighs/atom = 77.792000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.600705612883, Press = 0.945948476476302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.877   -13875.877   -14017.509   -14017.509    273.99573    273.99573    48085.342    48085.342    -553.8456    -553.8456 
   59000   -13879.204   -13879.204   -14020.828   -14020.828    273.98126    273.98126    48005.809    48005.809    1527.5475    1527.5475 
Loop time of 77.6127 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.559 hours/ns, 12.884 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    | 77.247     | 77.247     | 77.247     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046407   | 0.046407   | 0.046407   |   0.0 |  0.06
Output  | 0.00010419 | 0.00010419 | 0.00010419 |   0.0 |  0.00
Modify  | 0.2773     | 0.2773     | 0.2773     |   0.0 |  0.36
Other   |            | 0.04188    |            |       |  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:      311118.0 ave      311118 max      311118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311118
Ave neighs/atom = 77.779500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.583118712788, Press = 1.21825455032152
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13879.204   -13879.204   -14020.828   -14020.828    273.98126    273.98126    48005.809    48005.809    1527.5475    1527.5475 
   60000   -13874.274   -13874.274    -14018.06    -14018.06    278.16322    278.16322    48010.156    48010.156    1633.3559    1633.3559 
Loop time of 77.7543 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.598 hours/ns, 12.861 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    | 77.388     | 77.388     | 77.388     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046467   | 0.046467   | 0.046467   |   0.0 |  0.06
Output  | 0.00010435 | 0.00010435 | 0.00010435 |   0.0 |  0.00
Modify  | 0.27745    | 0.27745    | 0.27745    |   0.0 |  0.36
Other   |            | 0.04199    |            |       |  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:      311390.0 ave      311390 max      311390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311390
Ave neighs/atom = 77.847500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.559329166751, Press = -0.123866567862552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.274   -13874.274    -14018.06    -14018.06    278.16322    278.16322    48010.156    48010.156    1633.3559    1633.3559 
   61000   -13876.504   -13876.504   -14016.001   -14016.001    269.86672    269.86672    48074.823    48074.823   -224.72889   -224.72889 
Loop time of 77.7081 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.586 hours/ns, 12.869 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    | 77.342     | 77.342     | 77.342     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046381   | 0.046381   | 0.046381   |   0.0 |  0.06
Output  | 0.00010406 | 0.00010406 | 0.00010406 |   0.0 |  0.00
Modify  | 0.27733    | 0.27733    | 0.27733    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311206.0 ave      311206 max      311206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311206
Ave neighs/atom = 77.801500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.546986383923, Press = -0.047816377802818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.504   -13876.504   -14016.001   -14016.001    269.86672    269.86672    48074.823    48074.823   -224.72889   -224.72889 
   62000   -13872.903   -13872.903   -14016.166   -14016.166    277.15227    277.15227    48089.034    48089.034   -536.23078   -536.23078 
Loop time of 77.7058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.585 hours/ns, 12.869 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    | 77.34      | 77.34      | 77.34      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046716   | 0.046716   | 0.046716   |   0.0 |  0.06
Output  | 0.00010446 | 0.00010446 | 0.00010446 |   0.0 |  0.00
Modify  | 0.2772     | 0.2772     | 0.2772     |   0.0 |  0.36
Other   |            | 0.04186    |            |       |  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:      311168.0 ave      311168 max      311168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311168
Ave neighs/atom = 77.792000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.531069795302, Press = 0.400957063571111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13872.903   -13872.903   -14016.166   -14016.166    277.15227    277.15227    48089.034    48089.034   -536.23078   -536.23078 
   63000    -13876.98    -13876.98   -14017.932   -14017.932    272.68069    272.68069    48064.993    48064.993   -73.117439   -73.117439 
Loop time of 77.6783 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.577 hours/ns, 12.874 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    | 77.313     | 77.313     | 77.313     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046213   | 0.046213   | 0.046213   |   0.0 |  0.06
Output  | 0.00010303 | 0.00010303 | 0.00010303 |   0.0 |  0.00
Modify  | 0.27719    | 0.27719    | 0.27719    |   0.0 |  0.36
Other   |            | 0.04182    |            |       |  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:      311110.0 ave      311110 max      311110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311110
Ave neighs/atom = 77.777500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.534676608308, Press = 0.459287768006096
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13876.98    -13876.98   -14017.932   -14017.932    272.68069    272.68069    48064.993    48064.993   -73.117439   -73.117439 
   64000    -13874.03    -13874.03    -14014.67    -14014.67    272.07671    272.07671    48060.705    48060.705    399.93924    399.93924 
Loop time of 77.7546 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.599 hours/ns, 12.861 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    | 77.389     | 77.389     | 77.389     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046216   | 0.046216   | 0.046216   |   0.0 |  0.06
Output  | 0.00010405 | 0.00010405 | 0.00010405 |   0.0 |  0.00
Modify  | 0.27702    | 0.27702    | 0.27702    |   0.0 |  0.36
Other   |            | 0.04182    |            |       |  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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.545034135976, Press = 0.33232618558594
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13874.03    -13874.03    -14014.67    -14014.67    272.07671    272.07671    48060.705    48060.705    399.93924    399.93924 
   65000   -13878.453   -13878.453    -14017.76    -14017.76    269.49779    269.49779    48068.652    48068.652   -159.02085   -159.02085 
Loop time of 77.6565 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.571 hours/ns, 12.877 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    | 77.291     | 77.291     | 77.291     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046397   | 0.046397   | 0.046397   |   0.0 |  0.06
Output  | 0.00010166 | 0.00010166 | 0.00010166 |   0.0 |  0.00
Modify  | 0.27712    | 0.27712    | 0.27712    |   0.0 |  0.36
Other   |            | 0.04185    |            |       |  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:      311116.0 ave      311116 max      311116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311116
Ave neighs/atom = 77.779000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.538339514407, Press = 0.263864788051067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13878.453   -13878.453    -14017.76    -14017.76    269.49779    269.49779    48068.652    48068.652   -159.02085   -159.02085 
   66000   -13870.485   -13870.485   -14012.867   -14012.867    275.44885    275.44885    48056.514    48056.514    728.55542    728.55542 
Loop time of 77.7122 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.587 hours/ns, 12.868 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    | 77.346     | 77.346     | 77.346     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046514   | 0.046514   | 0.046514   |   0.0 |  0.06
Output  | 0.00010212 | 0.00010212 | 0.00010212 |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311168.0 ave      311168 max      311168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311168
Ave neighs/atom = 77.792000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.561534004868, Press = 0.573806302696305
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13870.485   -13870.485   -14012.867   -14012.867    275.44885    275.44885    48056.514    48056.514    728.55542    728.55542 
   67000   -13878.159   -13878.159   -14018.819   -14018.819     272.1157     272.1157    48016.619    48016.619    1261.4799    1261.4799 
Loop time of 77.6864 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.580 hours/ns, 12.872 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    | 77.321     | 77.321     | 77.321     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046429   | 0.046429   | 0.046429   |   0.0 |  0.06
Output  | 0.00010189 | 0.00010189 | 0.00010189 |   0.0 |  0.00
Modify  | 0.27699    | 0.27699    | 0.27699    |   0.0 |  0.36
Other   |            | 0.04189    |            |       |  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:      311166.0 ave      311166 max      311166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311166
Ave neighs/atom = 77.791500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.563176075374, Press = 0.39476628303194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13878.159   -13878.159   -14018.819   -14018.819     272.1157     272.1157    48016.619    48016.619    1261.4799    1261.4799 
   68000   -13873.049   -13873.049   -14014.122   -14014.122    272.91466    272.91466    48062.341    48062.341    386.17035    386.17035 
Loop time of 77.6835 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.579 hours/ns, 12.873 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    | 77.318     | 77.318     | 77.318     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046245   | 0.046245   | 0.046245   |   0.0 |  0.06
Output  | 0.00010394 | 0.00010394 | 0.00010394 |   0.0 |  0.00
Modify  | 0.27705    | 0.27705    | 0.27705    |   0.0 |  0.36
Other   |            | 0.04183    |            |       |  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:      311234.0 ave      311234 max      311234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311234
Ave neighs/atom = 77.808500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.569584966822, Press = -0.365779111988616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.049   -13873.049   -14014.122   -14014.122    272.91466    272.91466    48062.341    48062.341    386.17035    386.17035 
   69000   -13877.427   -13877.427    -14016.64    -14016.64    269.31797    269.31797     48115.43     48115.43    -1405.382    -1405.382 
Loop time of 77.7201 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.589 hours/ns, 12.867 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    | 77.354     | 77.354     | 77.354     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046436   | 0.046436   | 0.046436   |   0.0 |  0.06
Output  | 0.00010481 | 0.00010481 | 0.00010481 |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311074.0 ave      311074 max      311074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311074
Ave neighs/atom = 77.768500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.547900707176, Press = 0.168866377086888
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.427   -13877.427    -14016.64    -14016.64    269.31797    269.31797     48115.43     48115.43    -1405.382    -1405.382 
   70000   -13873.997   -13873.997   -14013.944   -14013.944    270.73656    270.73656    48086.195    48086.195   -323.35439   -323.35439 
Loop time of 77.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.596 hours/ns, 12.863 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    | 77.378     | 77.378     | 77.378     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046498   | 0.046498   | 0.046498   |   0.0 |  0.06
Output  | 0.0001039  | 0.0001039  | 0.0001039  |   0.0 |  0.00
Modify  | 0.27761    | 0.27761    | 0.27761    |   0.0 |  0.36
Other   |            | 0.04207    |            |       |  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:      311090.0 ave      311090 max      311090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311090
Ave neighs/atom = 77.772500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.528153939706, Press = 0.892996362628712
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.997   -13873.997   -14013.944   -14013.944    270.73656    270.73656    48086.195    48086.195   -323.35439   -323.35439 
   71000   -13877.717   -13877.717   -14018.207   -14018.207    271.78741    271.78741     48009.32     48009.32    1590.7435    1590.7435 
Loop time of 77.6279 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.563 hours/ns, 12.882 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    | 77.262     | 77.262     | 77.262     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046513   | 0.046513   | 0.046513   |   0.0 |  0.06
Output  | 0.00010393 | 0.00010393 | 0.00010393 |   0.0 |  0.00
Modify  | 0.2773     | 0.2773     | 0.2773     |   0.0 |  0.36
Other   |            | 0.04192    |            |       |  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:      311070.0 ave      311070 max      311070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311070
Ave neighs/atom = 77.767500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.491529452895, Press = 0.580049188481946
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13877.717   -13877.717   -14018.207   -14018.207    271.78741    271.78741     48009.32     48009.32    1590.7435    1590.7435 
   72000   -13878.095   -13878.095   -14017.981   -14017.981    270.61749    270.61749    48022.904    48022.904    1162.0243    1162.0243 
Loop time of 77.7036 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.584 hours/ns, 12.869 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    | 77.338     | 77.338     | 77.338     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046399   | 0.046399   | 0.046399   |   0.0 |  0.06
Output  | 0.00010439 | 0.00010439 | 0.00010439 |   0.0 |  0.00
Modify  | 0.27735    | 0.27735    | 0.27735    |   0.0 |  0.36
Other   |            | 0.04193    |            |       |  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:      311236.0 ave      311236 max      311236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311236
Ave neighs/atom = 77.809000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.484117124182, Press = -0.339334223051009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13878.095   -13878.095   -14017.981   -14017.981    270.61749    270.61749    48022.904    48022.904    1162.0243    1162.0243 
   73000   -13873.514   -13873.514   -14016.874   -14016.874    277.33915    277.33915     48109.99     48109.99   -1176.8477   -1176.8477 
Loop time of 77.6373 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.566 hours/ns, 12.880 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    | 77.271     | 77.271     | 77.271     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046411   | 0.046411   | 0.046411   |   0.0 |  0.06
Output  | 0.00010128 | 0.00010128 | 0.00010128 |   0.0 |  0.00
Modify  | 0.27736    | 0.27736    | 0.27736    |   0.0 |  0.36
Other   |            | 0.042      |            |       |  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:      311174.0 ave      311174 max      311174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311174
Ave neighs/atom = 77.793500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.489775920078, Press = -0.242396288856656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13873.514   -13873.514   -14016.874   -14016.874    277.33915    277.33915     48109.99     48109.99   -1176.8477   -1176.8477 
   74000   -13875.487   -13875.487   -14017.439   -14017.439    274.61586    274.61586     48102.12     48102.12   -1056.7228   -1056.7228 
Loop time of 77.6777 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.577 hours/ns, 12.874 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    | 77.312     | 77.312     | 77.312     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046643   | 0.046643   | 0.046643   |   0.0 |  0.06
Output  | 0.00010326 | 0.00010326 | 0.00010326 |   0.0 |  0.00
Modify  | 0.27738    | 0.27738    | 0.27738    |   0.0 |  0.36
Other   |            | 0.04188    |            |       |  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:      311120.0 ave      311120 max      311120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311120
Ave neighs/atom = 77.780000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.494106150463, Press = 0.456079570209562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13875.487   -13875.487   -14017.439   -14017.439    274.61586    274.61586     48102.12     48102.12   -1056.7228   -1056.7228 
   75000   -13880.743   -13880.743   -14017.901   -14017.901    265.33973    265.33973    48052.736    48052.736    349.89003    349.89003 
Loop time of 77.6823 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.578 hours/ns, 12.873 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    | 77.317     | 77.317     | 77.317     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04624    | 0.04624    | 0.04624    |   0.0 |  0.06
Output  | 0.0001034  | 0.0001034  | 0.0001034  |   0.0 |  0.00
Modify  | 0.27728    | 0.27728    | 0.27728    |   0.0 |  0.36
Other   |            | 0.04196    |            |       |  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:      311052.0 ave      311052 max      311052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311052
Ave neighs/atom = 77.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.494963485413, Press = 0.56090342225168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13880.743   -13880.743   -14017.901   -14017.901    265.33973    265.33973    48052.736    48052.736    349.89003    349.89003 
   76000   -13874.876   -13874.876   -14015.274   -14015.274    271.61041    271.61041    48051.515    48051.515    743.79307    743.79307 
Loop time of 77.7136 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.587 hours/ns, 12.868 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    | 77.348     | 77.348     | 77.348     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046441   | 0.046441   | 0.046441   |   0.0 |  0.06
Output  | 0.00010067 | 0.00010067 | 0.00010067 |   0.0 |  0.00
Modify  | 0.2775     | 0.2775     | 0.2775     |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474946739952, Press = 0.313176007125143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.876   -13874.876   -14015.274   -14015.274    271.61041    271.61041    48051.515    48051.515    743.79307    743.79307 
   77000   -13874.503   -13874.503   -14015.573   -14015.573    272.90903    272.90903    48075.053    48075.053    -99.66767    -99.66767 
Loop time of 77.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.587 hours/ns, 12.868 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    | 77.347     | 77.347     | 77.347     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046468   | 0.046468   | 0.046468   |   0.0 |  0.06
Output  | 0.00010346 | 0.00010346 | 0.00010346 |   0.0 |  0.00
Modify  | 0.27767    | 0.27767    | 0.27767    |   0.0 |  0.36
Other   |            | 0.04193    |            |       |  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:      311198.0 ave      311198 max      311198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311198
Ave neighs/atom = 77.799500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.451156776324, Press = 0.206715099642119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.503   -13874.503   -14015.573   -14015.573    272.90903    272.90903    48075.053    48075.053    -99.66767    -99.66767 
   78000   -13876.474   -13876.474   -14018.178   -14018.178    274.13587    274.13587    48083.958    48083.958   -529.65365   -529.65365 
Loop time of 77.7391 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.594 hours/ns, 12.864 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    | 77.373     | 77.373     | 77.373     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046285   | 0.046285   | 0.046285   |   0.0 |  0.06
Output  | 0.00010341 | 0.00010341 | 0.00010341 |   0.0 |  0.00
Modify  | 0.27762    | 0.27762    | 0.27762    |   0.0 |  0.36
Other   |            | 0.04192    |            |       |  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:      311098.0 ave      311098 max      311098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311098
Ave neighs/atom = 77.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.463216580598, Press = 0.0776585092704186
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.474   -13876.474   -14018.178   -14018.178    274.13587    274.13587    48083.958    48083.958   -529.65365   -529.65365 
   79000   -13868.289   -13868.289   -14013.332   -14013.332     280.5961     280.5961    48117.167    48117.167   -885.83559   -885.83559 
Loop time of 77.8521 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.626 hours/ns, 12.845 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    | 77.486     | 77.486     | 77.486     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046442   | 0.046442   | 0.046442   |   0.0 |  0.06
Output  | 0.00010355 | 0.00010355 | 0.00010355 |   0.0 |  0.00
Modify  | 0.27753    | 0.27753    | 0.27753    |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311186.0 ave      311186 max      311186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311186
Ave neighs/atom = 77.796500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.475556669753, Press = 0.605579629110477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13868.289   -13868.289   -14013.332   -14013.332     280.5961     280.5961    48117.167    48117.167   -885.83559   -885.83559 
   80000   -13879.205   -13879.205   -14018.735   -14018.735    269.93137    269.93137    48003.113    48003.113    1660.1958    1660.1958 
Loop time of 77.8149 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.615 hours/ns, 12.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.449     | 77.449     | 77.449     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046364   | 0.046364   | 0.046364   |   0.0 |  0.06
Output  | 0.00010434 | 0.00010434 | 0.00010434 |   0.0 |  0.00
Modify  | 0.27763    | 0.27763    | 0.27763    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311250.0 ave      311250 max      311250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311250
Ave neighs/atom = 77.812500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.484983580989, Press = 0.640307373541709
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13879.205   -13879.205   -14018.735   -14018.735    269.93137    269.93137    48003.113    48003.113    1660.1958    1660.1958 
   81000   -13874.385   -13874.385    -14017.94    -14017.94    277.71835    277.71835    48031.932    48031.932    1039.7841    1039.7841 
Loop time of 77.6272 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.563 hours/ns, 12.882 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    | 77.261     | 77.261     | 77.261     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04638    | 0.04638    | 0.04638    |   0.0 |  0.06
Output  | 0.0001031  | 0.0001031  | 0.0001031  |   0.0 |  0.00
Modify  | 0.2776     | 0.2776     | 0.2776     |   0.0 |  0.36
Other   |            | 0.04202    |            |       |  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:      311224.0 ave      311224 max      311224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311224
Ave neighs/atom = 77.806000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.469262834749, Press = -0.232944707830403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13874.385   -13874.385    -14017.94    -14017.94    277.71835    277.71835    48031.932    48031.932    1039.7841    1039.7841 
   82000    -13876.68    -13876.68   -14018.068   -14018.068    273.52588    273.52588    48091.339    48091.339   -749.76525   -749.76525 
Loop time of 77.6917 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.581 hours/ns, 12.871 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    | 77.326     | 77.326     | 77.326     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046401   | 0.046401   | 0.046401   |   0.0 |  0.06
Output  | 0.00010233 | 0.00010233 | 0.00010233 |   0.0 |  0.00
Modify  | 0.27755    | 0.27755    | 0.27755    |   0.0 |  0.36
Other   |            | 0.042      |            |       |  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:      311286.0 ave      311286 max      311286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311286
Ave neighs/atom = 77.821500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.464635675149, Press = -0.151439606086544
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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    -13876.68    -13876.68   -14018.068   -14018.068    273.52588    273.52588    48091.339    48091.339   -749.76525   -749.76525 
   83000   -13876.258   -13876.258   -14015.821   -14015.821    269.99517    269.99517    48073.894    48073.894   -127.39565   -127.39565 
Loop time of 77.7403 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.595 hours/ns, 12.863 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    | 77.374     | 77.374     | 77.374     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046594   | 0.046594   | 0.046594   |   0.0 |  0.06
Output  | 9.9882e-05 | 9.9882e-05 | 9.9882e-05 |   0.0 |  0.00
Modify  | 0.27769    | 0.27769    | 0.27769    |   0.0 |  0.36
Other   |            | 0.04206    |            |       |  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:      311214.0 ave      311214 max      311214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311214
Ave neighs/atom = 77.803500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434361559581, Press = 0.251546290511344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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   -13876.258   -13876.258   -14015.821   -14015.821    269.99517    269.99517    48073.894    48073.894   -127.39565   -127.39565 
   84000   -13878.502   -13878.502   -14018.466   -14018.466    270.76875    270.76875    48070.457    48070.457   -268.03428   -268.03428 
Loop time of 77.7758 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.604 hours/ns, 12.857 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    | 77.409     | 77.409     | 77.409     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046288   | 0.046288   | 0.046288   |   0.0 |  0.06
Output  | 0.00010288 | 0.00010288 | 0.00010288 |   0.0 |  0.00
Modify  | 0.27805    | 0.27805    | 0.27805    |   0.0 |  0.36
Other   |            | 0.04214    |            |       |  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:      311202.0 ave      311202 max      311202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311202
Ave neighs/atom = 77.800500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.427780611963, Press = 0.299024711257014
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   84000   -13878.502   -13878.502   -14018.466   -14018.466    270.76875    270.76875    48070.457    48070.457   -268.03428   -268.03428 
   85000    -13875.13    -13875.13   -14016.301   -14016.301    273.10427    273.10427    48060.708    48060.708    257.80189    257.80189 
Loop time of 77.7108 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.586 hours/ns, 12.868 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    | 77.344     | 77.344     | 77.344     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046537   | 0.046537   | 0.046537   |   0.0 |  0.06
Output  | 0.00010298 | 0.00010298 | 0.00010298 |   0.0 |  0.00
Modify  | 0.27794    | 0.27794    | 0.27794    |   0.0 |  0.36
Other   |            | 0.04205    |            |       |  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:      311188.0 ave      311188 max      311188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311188
Ave neighs/atom = 77.797000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.407174917405, Press = 0.297282374167074
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   85000    -13875.13    -13875.13   -14016.301   -14016.301    273.10427    273.10427    48060.708    48060.708    257.80189    257.80189 
   86000   -13873.524   -13873.524   -14016.949   -14016.949    277.46433    277.46433     48060.21     48060.21    263.37301    263.37301 
Loop time of 77.7176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.588 hours/ns, 12.867 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    | 77.352     | 77.352     | 77.352     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046238   | 0.046238   | 0.046238   |   0.0 |  0.06
Output  | 9.3935e-05 | 9.3935e-05 | 9.3935e-05 |   0.0 |  0.00
Modify  | 0.27739    | 0.27739    | 0.27739    |   0.0 |  0.36
Other   |            | 0.04194    |            |       |  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:      311250.0 ave      311250 max      311250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311250
Ave neighs/atom = 77.812500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404496684171, Press = 0.0049529853869842
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   86000   -13873.524   -13873.524   -14016.949   -14016.949    277.46433    277.46433     48060.21     48060.21    263.37301    263.37301 
   87000    -13876.26    -13876.26   -14016.229   -14016.229    270.77877    270.77877    48081.901    48081.901   -367.89327   -367.89327 
Loop time of 77.6275 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.563 hours/ns, 12.882 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    | 77.262     | 77.262     | 77.262     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046341   | 0.046341   | 0.046341   |   0.0 |  0.06
Output  | 0.00010172 | 0.00010172 | 0.00010172 |   0.0 |  0.00
Modify  | 0.27713    | 0.27713    | 0.27713    |   0.0 |  0.36
Other   |            | 0.0419     |            |       |  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:      311212.0 ave      311212 max      311212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311212
Ave neighs/atom = 77.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.407438747546, Press = -0.0616734048610004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   87000    -13876.26    -13876.26   -14016.229   -14016.229    270.77877    270.77877    48081.901    48081.901   -367.89327   -367.89327 
   88000   -13879.271   -13879.271   -14018.385   -14018.385     269.1252     269.1252    48084.551    48084.551   -673.87049   -673.87049 
Loop time of 77.6348 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.565 hours/ns, 12.881 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    | 77.269     | 77.269     | 77.269     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046348   | 0.046348   | 0.046348   |   0.0 |  0.06
Output  | 0.00010299 | 0.00010299 | 0.00010299 |   0.0 |  0.00
Modify  | 0.27741    | 0.27741    | 0.27741    |   0.0 |  0.36
Other   |            | 0.04193    |            |       |  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:      311074.0 ave      311074 max      311074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311074
Ave neighs/atom = 77.768500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404959366574, Press = 0.370537067764638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   88000   -13879.271   -13879.271   -14018.385   -14018.385     269.1252     269.1252    48084.551    48084.551   -673.87049   -673.87049 
   89000   -13872.575   -13872.575   -14015.171   -14015.171    275.86069    275.86069    48040.736    48040.736    930.21229    930.21229 
Loop time of 77.8214 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.617 hours/ns, 12.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.455     | 77.455     | 77.455     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046705   | 0.046705   | 0.046705   |   0.0 |  0.06
Output  | 0.00010356 | 0.00010356 | 0.00010356 |   0.0 |  0.00
Modify  | 0.27729    | 0.27729    | 0.27729    |   0.0 |  0.36
Other   |            | 0.04195    |            |       |  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:      311188.0 ave      311188 max      311188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311188
Ave neighs/atom = 77.797000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.405121624158, Press = 0.605278642065824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   89000   -13872.575   -13872.575   -14015.171   -14015.171    275.86069    275.86069    48040.736    48040.736    930.21229    930.21229 
   90000   -13877.637   -13877.637   -14020.205   -14020.205    275.80789    275.80789    48004.367    48004.367    1487.8864    1487.8864 
Loop time of 77.7262 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.591 hours/ns, 12.866 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    | 77.36      | 77.36      | 77.36      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046332   | 0.046332   | 0.046332   |   0.0 |  0.06
Output  | 0.00010339 | 0.00010339 | 0.00010339 |   0.0 |  0.00
Modify  | 0.27736    | 0.27736    | 0.27736    |   0.0 |  0.36
Other   |            | 0.04194    |            |       |  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:      311176.0 ave      311176 max      311176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311176
Ave neighs/atom = 77.794000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.403925249539, Press = -0.214910771501353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   90000   -13877.637   -13877.637   -14020.205   -14020.205    275.80789    275.80789    48004.367    48004.367    1487.8864    1487.8864 
   91000   -13874.333   -13874.333   -14018.891   -14018.891    279.65723    279.65723    48120.079    48120.079   -1588.5646   -1588.5646 
Loop time of 77.8345 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.621 hours/ns, 12.848 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    | 77.469     | 77.469     | 77.469     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046329   | 0.046329   | 0.046329   |   0.0 |  0.06
Output  | 0.00010223 | 0.00010223 | 0.00010223 |   0.0 |  0.00
Modify  | 0.27734    | 0.27734    | 0.27734    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311360.0 ave      311360 max      311360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311360
Ave neighs/atom = 77.840000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.400035441484, Press = -0.309040600074409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   91000   -13874.333   -13874.333   -14018.891   -14018.891    279.65723    279.65723    48120.079    48120.079   -1588.5646   -1588.5646 
   92000    -13877.25    -13877.25    -14017.19    -14017.19    270.72278    270.72278    48093.099    48093.099   -814.40528   -814.40528 
Loop time of 77.8346 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.621 hours/ns, 12.848 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    | 77.469     | 77.469     | 77.469     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046362   | 0.046362   | 0.046362   |   0.0 |  0.06
Output  | 0.00010362 | 0.00010362 | 0.00010362 |   0.0 |  0.00
Modify  | 0.27737    | 0.27737    | 0.27737    |   0.0 |  0.36
Other   |            | 0.04195    |            |       |  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:      311228.0 ave      311228 max      311228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311228
Ave neighs/atom = 77.807000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.409784147895, Press = 0.237570015184723
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   92000    -13877.25    -13877.25    -14017.19    -14017.19    270.72278    270.72278    48093.099    48093.099   -814.40528   -814.40528 
   93000   -13872.279   -13872.279   -14014.143   -14014.143    274.44516    274.44516    48073.499    48073.499    238.58972    238.58972 
Loop time of 77.8472 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.624 hours/ns, 12.846 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    | 77.481     | 77.481     | 77.481     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046295   | 0.046295   | 0.046295   |   0.0 |  0.06
Output  | 0.00010333 | 0.00010333 | 0.00010333 |   0.0 |  0.00
Modify  | 0.27747    | 0.27747    | 0.27747    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311222.0 ave      311222 max      311222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311222
Ave neighs/atom = 77.805500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.419008017947, Press = 0.302450351505044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   93000   -13872.279   -13872.279   -14014.143   -14014.143    274.44516    274.44516    48073.499    48073.499    238.58972    238.58972 
   94000   -13875.475   -13875.475   -14016.503   -14016.503    272.82855    272.82855    48043.078    48043.078    797.35946    797.35946 
Loop time of 77.8328 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.620 hours/ns, 12.848 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    | 77.467     | 77.467     | 77.467     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046381   | 0.046381   | 0.046381   |   0.0 |  0.06
Output  | 0.0001022  | 0.0001022  | 0.0001022  |   0.0 |  0.00
Modify  | 0.27738    | 0.27738    | 0.27738    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311208.0 ave      311208 max      311208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311208
Ave neighs/atom = 77.802000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.421603522505, Press = -0.0373230355840853
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   94000   -13875.475   -13875.475   -14016.503   -14016.503    272.82855    272.82855    48043.078    48043.078    797.35946    797.35946 
   95000   -13873.385   -13873.385   -14016.681   -14016.681     277.2167     277.2167    48100.051    48100.051   -858.21072   -858.21072 
Loop time of 77.6905 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.581 hours/ns, 12.872 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    | 77.325     | 77.325     | 77.325     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046241   | 0.046241   | 0.046241   |   0.0 |  0.06
Output  | 0.00010219 | 0.00010219 | 0.00010219 |   0.0 |  0.00
Modify  | 0.27745    | 0.27745    | 0.27745    |   0.0 |  0.36
Other   |            | 0.04194    |            |       |  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:      311290.0 ave      311290 max      311290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311290
Ave neighs/atom = 77.822500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.440797945365, Press = -0.541796454029246
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   95000   -13873.385   -13873.385   -14016.681   -14016.681     277.2167     277.2167    48100.051    48100.051   -858.21072   -858.21072 
   96000   -13874.259   -13874.259   -14016.251   -14016.251    274.69438    274.69438    48152.697    48152.697   -2439.5003   -2439.5003 
Loop time of 77.7377 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.594 hours/ns, 12.864 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    | 77.372     | 77.372     | 77.372     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046278   | 0.046278   | 0.046278   |   0.0 |  0.06
Output  | 0.00010157 | 0.00010157 | 0.00010157 |   0.0 |  0.00
Modify  | 0.27733    | 0.27733    | 0.27733    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311212.0 ave      311212 max      311212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311212
Ave neighs/atom = 77.803000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434642468071, Press = 0.218678704668331
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   96000   -13874.259   -13874.259   -14016.251   -14016.251    274.69438    274.69438    48152.697    48152.697   -2439.5003   -2439.5003 
   97000   -13873.362   -13873.362   -14017.692   -14017.692     279.2158     279.2158     48071.14     48071.14   -144.20123   -144.20123 
Loop time of 77.8327 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.620 hours/ns, 12.848 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    | 77.467     | 77.467     | 77.467     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046502   | 0.046502   | 0.046502   |   0.0 |  0.06
Output  | 0.00012206 | 0.00012206 | 0.00012206 |   0.0 |  0.00
Modify  | 0.27736    | 0.27736    | 0.27736    |   0.0 |  0.36
Other   |            | 0.04187    |            |       |  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:      311098.0 ave      311098 max      311098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311098
Ave neighs/atom = 77.774500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.456701278154, Press = 0.481414817868246
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   97000   -13873.362   -13873.362   -14017.692   -14017.692     279.2158     279.2158     48071.14     48071.14   -144.20123   -144.20123 
   98000   -13882.755   -13882.755   -14019.004   -14019.004    263.58352    263.58352    48038.244    48038.244    564.03274    564.03274 
Loop time of 77.8305 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.620 hours/ns, 12.848 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    | 77.465     | 77.465     | 77.465     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046339   | 0.046339   | 0.046339   |   0.0 |  0.06
Output  | 0.00010398 | 0.00010398 | 0.00010398 |   0.0 |  0.00
Modify  | 0.27733    | 0.27733    | 0.27733    |   0.0 |  0.36
Other   |            | 0.04198    |            |       |  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:      311158.0 ave      311158 max      311158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311158
Ave neighs/atom = 77.789500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.448801294686, Press = 0.249672415310167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   98000   -13882.755   -13882.755   -14019.004   -14019.004    263.58352    263.58352    48038.244    48038.244    564.03274    564.03274 
   99000   -13874.268   -13874.268   -14017.673   -14017.673    277.42601    277.42601    48048.592    48048.592    576.96391    576.96391 
Loop time of 77.7505 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.597 hours/ns, 12.862 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    | 77.385     | 77.385     | 77.385     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04638    | 0.04638    | 0.04638    |   0.0 |  0.06
Output  | 0.00010089 | 0.00010089 | 0.00010089 |   0.0 |  0.00
Modify  | 0.27745    | 0.27745    | 0.27745    |   0.0 |  0.36
Other   |            | 0.04201    |            |       |  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:      311280.0 ave      311280 max      311280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311280
Ave neighs/atom = 77.820000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.430616482871, Press = 0.180001900614164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
   99000   -13874.268   -13874.268   -14017.673   -14017.673    277.42601    277.42601    48048.592    48048.592    576.96391    576.96391 
  100000   -13875.999   -13875.999    -14017.55    -14017.55    273.84069    273.84069    48052.621    48052.621    321.65403    321.65403 
Loop time of 77.6737 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.576 hours/ns, 12.874 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    | 77.308     | 77.308     | 77.308     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046287   | 0.046287   | 0.046287   |   0.0 |  0.06
Output  | 0.00010691 | 0.00010691 | 0.00010691 |   0.0 |  0.00
Modify  | 0.27748    | 0.27748    | 0.27748    |   0.0 |  0.36
Other   |            | 0.04212    |            |       |  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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.417638457045, Press = -0.139968399527881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  100000   -13875.999   -13875.999    -14017.55    -14017.55    273.84069    273.84069    48052.621    48052.621    321.65403    321.65403 
  101000   -13876.237   -13876.237   -14018.214   -14018.214    274.66465    274.66465    48143.361    48143.361   -2260.4498   -2260.4498 
Loop time of 77.7664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.602 hours/ns, 12.859 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    | 77.4       | 77.4       | 77.4       |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046491   | 0.046491   | 0.046491   |   0.0 |  0.06
Output  | 0.0001108  | 0.0001108  | 0.0001108  |   0.0 |  0.00
Modify  | 0.27752    | 0.27752    | 0.27752    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311172.0 ave      311172 max      311172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311172
Ave neighs/atom = 77.793000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.421209162905, Press = -0.169869305671389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  101000   -13876.237   -13876.237   -14018.214   -14018.214    274.66465    274.66465    48143.361    48143.361   -2260.4498   -2260.4498 
  102000   -13881.053   -13881.053   -14020.106   -14020.106    269.00631    269.00631     48089.87     48089.87   -1012.3476   -1012.3476 
Loop time of 77.7544 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.598 hours/ns, 12.861 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    | 77.388     | 77.388     | 77.388     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046459   | 0.046459   | 0.046459   |   0.0 |  0.06
Output  | 0.00010248 | 0.00010248 | 0.00010248 |   0.0 |  0.00
Modify  | 0.27732    | 0.27732    | 0.27732    |   0.0 |  0.36
Other   |            | 0.04204    |            |       |  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:      311220.0 ave      311220 max      311220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311220
Ave neighs/atom = 77.805000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.401514770225, Press = 0.739004392472375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  102000   -13881.053   -13881.053   -14020.106   -14020.106    269.00631    269.00631     48089.87     48089.87   -1012.3476   -1012.3476 
  103000   -13875.289   -13875.289   -14017.525   -14017.525    275.16506    275.16506     48039.31     48039.31    762.77439    762.77439 
Loop time of 77.6931 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.581 hours/ns, 12.871 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    | 77.327     | 77.327     | 77.327     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04631    | 0.04631    | 0.04631    |   0.0 |  0.06
Output  | 0.00010184 | 0.00010184 | 0.00010184 |   0.0 |  0.00
Modify  | 0.27755    | 0.27755    | 0.27755    |   0.0 |  0.36
Other   |            | 0.04207    |            |       |  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:      311242.0 ave      311242 max      311242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311242
Ave neighs/atom = 77.810500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.391919036894, Press = 0.237511487815607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  103000   -13875.289   -13875.289   -14017.525   -14017.525    275.16506    275.16506     48039.31     48039.31    762.77439    762.77439 
  104000   -13875.896   -13875.896   -14015.774   -14015.774    270.60323    270.60323    48054.723    48054.723    437.71755    437.71755 
Loop time of 77.7435 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.595 hours/ns, 12.863 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    | 77.377     | 77.377     | 77.377     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046315   | 0.046315   | 0.046315   |   0.0 |  0.06
Output  | 0.00010332 | 0.00010332 | 0.00010332 |   0.0 |  0.00
Modify  | 0.27758    | 0.27758    | 0.27758    |   0.0 |  0.36
Other   |            | 0.04199    |            |       |  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:      311192.0 ave      311192 max      311192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311192
Ave neighs/atom = 77.798000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384174106901, Press = 0.0265232575015293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  104000   -13875.896   -13875.896   -14015.774   -14015.774    270.60323    270.60323    48054.723    48054.723    437.71755    437.71755 
  105000    -13872.94    -13872.94   -14017.641   -14017.641    279.93525    279.93525     48080.68     48080.68   -454.97146   -454.97146 
Loop time of 77.6823 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.578 hours/ns, 12.873 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    | 77.316     | 77.316     | 77.316     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046409   | 0.046409   | 0.046409   |   0.0 |  0.06
Output  | 0.00010299 | 0.00010299 | 0.00010299 |   0.0 |  0.00
Modify  | 0.27802    | 0.27802    | 0.27802    |   0.0 |  0.36
Other   |            | 0.04204    |            |       |  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:      311158.0 ave      311158 max      311158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311158
Ave neighs/atom = 77.789500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.378521867743, Press = 0.133319050578827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  105000    -13872.94    -13872.94   -14017.641   -14017.641    279.93525    279.93525     48080.68     48080.68   -454.97146   -454.97146 
  106000   -13876.808   -13876.808   -14016.507   -14016.507    270.25639    270.25639    48060.671    48060.671    243.77744    243.77744 
Loop time of 77.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.622 hours/ns, 12.847 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.473     | 77.473     | 77.473     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046368   | 0.046368   | 0.046368   |   0.0 |  0.06
Output  | 0.00010007 | 0.00010007 | 0.00010007 |   0.0 |  0.00
Modify  | 0.27738    | 0.27738    | 0.27738    |   0.0 |  0.36
Other   |            | 0.04199    |            |       |  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:      311150.0 ave      311150 max      311150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311150
Ave neighs/atom = 77.787500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.391565815601, Press = 0.185117987906683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  106000   -13876.808   -13876.808   -14016.507   -14016.507    270.25639    270.25639    48060.671    48060.671    243.77744    243.77744 
  107000   -13870.664   -13870.664   -14015.276   -14015.276    279.76013    279.76013    48062.793    48062.793    412.51664    412.51664 
Loop time of 77.7162 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.588 hours/ns, 12.867 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    | 77.35      | 77.35      | 77.35      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046306   | 0.046306   | 0.046306   |   0.0 |  0.06
Output  | 0.00010359 | 0.00010359 | 0.00010359 |   0.0 |  0.00
Modify  | 0.27765    | 0.27765    | 0.27765    |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311238.0 ave      311238 max      311238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311238
Ave neighs/atom = 77.809500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396773002123, Press = 0.258729752353924
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  107000   -13870.664   -13870.664   -14015.276   -14015.276    279.76013    279.76013    48062.793    48062.793    412.51664    412.51664 
  108000    -13877.01    -13877.01   -14016.148   -14016.148    269.17278    269.17278    48040.815    48040.815    850.58631    850.58631 
Loop time of 77.7895 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.608 hours/ns, 12.855 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    | 77.423     | 77.423     | 77.423     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047124   | 0.047124   | 0.047124   |   0.0 |  0.06
Output  | 0.00010378 | 0.00010378 | 0.00010378 |   0.0 |  0.00
Modify  | 0.27753    | 0.27753    | 0.27753    |   0.0 |  0.36
Other   |            | 0.04198    |            |       |  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:      311166.0 ave      311166 max      311166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311166
Ave neighs/atom = 77.791500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.399409294393, Press = 0.113806044503463
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  108000    -13877.01    -13877.01   -14016.148   -14016.148    269.17278    269.17278    48040.815    48040.815    850.58631    850.58631 
  109000   -13873.819   -13873.819   -14016.523   -14016.523    276.07076    276.07076     48065.49     48065.49    120.70807    120.70807 
Loop time of 77.8185 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.616 hours/ns, 12.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.452     | 77.452     | 77.452     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046657   | 0.046657   | 0.046657   |   0.0 |  0.06
Output  | 0.0001026  | 0.0001026  | 0.0001026  |   0.0 |  0.00
Modify  | 0.27758    | 0.27758    | 0.27758    |   0.0 |  0.36
Other   |            | 0.04196    |            |       |  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:      311324.0 ave      311324 max      311324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311324
Ave neighs/atom = 77.831000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.402441417921, Press = -0.22060664194171
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  109000   -13873.819   -13873.819   -14016.523   -14016.523    276.07076    276.07076     48065.49     48065.49    120.70807    120.70807 
  110000    -13876.65    -13876.65   -14017.565   -14017.565    272.60897    272.60897    48110.008    48110.008   -1164.1465   -1164.1465 
Loop time of 77.6766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.577 hours/ns, 12.874 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    | 77.31      | 77.31      | 77.31      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046263   | 0.046263   | 0.046263   |   0.0 |  0.06
Output  | 0.0001023  | 0.0001023  | 0.0001023  |   0.0 |  0.00
Modify  | 0.27771    | 0.27771    | 0.27771    |   0.0 |  0.36
Other   |            | 0.04201    |            |       |  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:      311156.0 ave      311156 max      311156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311156
Ave neighs/atom = 77.789000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396265637237, Press = -0.196915003385966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  110000    -13876.65    -13876.65   -14017.565   -14017.565    272.60897    272.60897    48110.008    48110.008   -1164.1465   -1164.1465 
  111000   -13873.656   -13873.656   -14017.334   -14017.334     277.9549     277.9549    48118.759    48118.759   -1421.8977   -1421.8977 
Loop time of 77.7325 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.592 hours/ns, 12.865 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    | 77.366     | 77.366     | 77.366     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046286   | 0.046286   | 0.046286   |   0.0 |  0.06
Output  | 0.00010275 | 0.00010275 | 0.00010275 |   0.0 |  0.00
Modify  | 0.27789    | 0.27789    | 0.27789    |   0.0 |  0.36
Other   |            | 0.04205    |            |       |  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:      311202.0 ave      311202 max      311202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311202
Ave neighs/atom = 77.800500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.392779634647, Press = 0.39887513412614
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  111000   -13873.656   -13873.656   -14017.334   -14017.334     277.9549     277.9549    48118.759    48118.759   -1421.8977   -1421.8977 
  112000   -13877.773   -13877.773   -14018.882   -14018.882    272.98418    272.98418    48037.899    48037.899    749.09898    749.09898 
Loop time of 77.6649 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.574 hours/ns, 12.876 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    | 77.299     | 77.299     | 77.299     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046498   | 0.046498   | 0.046498   |   0.0 |  0.06
Output  | 0.00011167 | 0.00011167 | 0.00011167 |   0.0 |  0.00
Modify  | 0.27769    | 0.27769    | 0.27769    |   0.0 |  0.36
Other   |            | 0.04201    |            |       |  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:      311258.0 ave      311258 max      311258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311258
Ave neighs/atom = 77.814500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.387971767548, Press = 0.4140265803039
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  112000   -13877.773   -13877.773   -14018.882   -14018.882    272.98418    272.98418    48037.899    48037.899    749.09898    749.09898 
  113000   -13876.741   -13876.741   -14017.152   -14017.152    271.63451    271.63451    48039.971    48039.971    843.48373    843.48373 
Loop time of 77.7615 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.600 hours/ns, 12.860 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    | 77.395     | 77.395     | 77.395     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046464   | 0.046464   | 0.046464   |   0.0 |  0.06
Output  | 0.00010033 | 0.00010033 | 0.00010033 |   0.0 |  0.00
Modify  | 0.27763    | 0.27763    | 0.27763    |   0.0 |  0.36
Other   |            | 0.04202    |            |       |  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:      311320.0 ave      311320 max      311320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311320
Ave neighs/atom = 77.830000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.390003364805, Press = -0.0938127045246648
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  113000   -13876.741   -13876.741   -14017.152   -14017.152    271.63451    271.63451    48039.971    48039.971    843.48373    843.48373 
  114000   -13873.277   -13873.277   -14014.411   -14014.411    273.03275    273.03275    48110.173    48110.173   -989.40528   -989.40528 
Loop time of 77.8287 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.619 hours/ns, 12.849 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    | 77.463     | 77.463     | 77.463     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046433   | 0.046433   | 0.046433   |   0.0 |  0.06
Output  | 0.00010151 | 0.00010151 | 0.00010151 |   0.0 |  0.00
Modify  | 0.27744    | 0.27744    | 0.27744    |   0.0 |  0.36
Other   |            | 0.04198    |            |       |  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:      311302.0 ave      311302 max      311302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311302
Ave neighs/atom = 77.825500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.387810592505, Press = -0.454741639003464
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  114000   -13873.277   -13873.277   -14014.411   -14014.411    273.03275    273.03275    48110.173    48110.173   -989.40528   -989.40528 
  115000   -13883.648   -13883.648   -14019.925   -14019.925    263.63638    263.63638    48123.249    48123.249   -2069.4837   -2069.4837 
Loop time of 77.6759 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.577 hours/ns, 12.874 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    | 77.31      | 77.31      | 77.31      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04627    | 0.04627    | 0.04627    |   0.0 |  0.06
Output  | 0.00010458 | 0.00010458 | 0.00010458 |   0.0 |  0.00
Modify  | 0.27743    | 0.27743    | 0.27743    |   0.0 |  0.36
Other   |            | 0.04197    |            |       |  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:      311118.0 ave      311118 max      311118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311118
Ave neighs/atom = 77.779500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.372960291419, Press = 0.191458960396625
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  115000   -13883.648   -13883.648   -14019.925   -14019.925    263.63638    263.63638    48123.249    48123.249   -2069.4837   -2069.4837 
  116000   -13875.228   -13875.228    -14015.46    -14015.46    271.28844    271.28844    48078.804    48078.804   -219.27228   -219.27228 
Loop time of 77.7527 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.598 hours/ns, 12.861 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    | 77.386     | 77.386     | 77.386     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046887   | 0.046887   | 0.046887   |   0.0 |  0.06
Output  | 0.00011018 | 0.00011018 | 0.00011018 |   0.0 |  0.00
Modify  | 0.27783    | 0.27783    | 0.27783    |   0.0 |  0.36
Other   |            | 0.04206    |            |       |  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:      311132.0 ave      311132 max      311132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311132
Ave neighs/atom = 77.783000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.363197917512, Press = 0.404077881388541
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  116000   -13875.228   -13875.228    -14015.46    -14015.46    271.28844    271.28844    48078.804    48078.804   -219.27228   -219.27228 
  117000   -13875.681   -13875.681   -14018.409   -14018.409    276.11641    276.11641    48037.049    48037.049    767.66848    767.66848 
Loop time of 77.7524 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.598 hours/ns, 12.861 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    | 77.386     | 77.386     | 77.386     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046619   | 0.046619   | 0.046619   |   0.0 |  0.06
Output  | 0.00010153 | 0.00010153 | 0.00010153 |   0.0 |  0.00
Modify  | 0.27756    | 0.27756    | 0.27756    |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311106.0 ave      311106 max      311106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311106
Ave neighs/atom = 77.776500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.357719682905, Press = 0.306700559202078
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  117000   -13875.681   -13875.681   -14018.409   -14018.409    276.11641    276.11641    48037.049    48037.049    767.66848    767.66848 
  118000   -13875.539   -13875.539    -14019.05    -14019.05    277.63125    277.63125    48039.084    48039.084     691.4016     691.4016 
Loop time of 77.7759 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.604 hours/ns, 12.857 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    | 77.41      | 77.41      | 77.41      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046357   | 0.046357   | 0.046357   |   0.0 |  0.06
Output  | 0.00010656 | 0.00010656 | 0.00010656 |   0.0 |  0.00
Modify  | 0.27762    | 0.27762    | 0.27762    |   0.0 |  0.36
Other   |            | 0.04203    |            |       |  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:      311256.0 ave      311256 max      311256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311256
Ave neighs/atom = 77.814000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.363918587435, Press = -0.012620000181825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  118000   -13875.539   -13875.539    -14019.05    -14019.05    277.63125    277.63125    48039.084    48039.084     691.4016     691.4016 
  119000   -13872.806   -13872.806     -14016.3     -14016.3    277.59955    277.59955    48101.231    48101.231   -974.92382   -974.92382 
Loop time of 77.6913 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.581 hours/ns, 12.871 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    | 77.325     | 77.325     | 77.325     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046364   | 0.046364   | 0.046364   |   0.0 |  0.06
Output  | 0.00010373 | 0.00010373 | 0.00010373 |   0.0 |  0.00
Modify  | 0.27755    | 0.27755    | 0.27755    |   0.0 |  0.36
Other   |            | 0.04201    |            |       |  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:      311380.0 ave      311380 max      311380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311380
Ave neighs/atom = 77.845000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.360924526311, Press = -0.0476342217278574
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  119000   -13872.806   -13872.806     -14016.3     -14016.3    277.59955    277.59955    48101.231    48101.231   -974.92382   -974.92382 
  120000   -13876.632   -13876.632   -14018.138   -14018.138    273.75382    273.75382    48079.809    48079.809   -452.00178   -452.00178 
Loop time of 77.885 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.635 hours/ns, 12.839 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    | 77.518     | 77.518     | 77.518     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046801   | 0.046801   | 0.046801   |   0.0 |  0.06
Output  | 0.00010939 | 0.00010939 | 0.00010939 |   0.0 |  0.00
Modify  | 0.27799    | 0.27799    | 0.27799    |   0.0 |  0.36
Other   |            | 0.04215    |            |       |  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:      311034.0 ave      311034 max      311034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311034
Ave neighs/atom = 77.758500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37569701131, Press = 0.236520571084789
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  120000   -13876.632   -13876.632   -14018.138   -14018.138    273.75382    273.75382    48079.809    48079.809   -452.00178   -452.00178 
  121000   -13873.914   -13873.914   -14019.135   -14019.135    280.94049    280.94049    48050.597    48050.597    336.51316    336.51316 
Loop time of 77.791 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.609 hours/ns, 12.855 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    | 77.424     | 77.424     | 77.424     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046557   | 0.046557   | 0.046557   |   0.0 |  0.06
Output  | 0.00010285 | 0.00010285 | 0.00010285 |   0.0 |  0.00
Modify  | 0.27805    | 0.27805    | 0.27805    |   0.0 |  0.36
Other   |            | 0.04207    |            |       |  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:      311230.0 ave      311230 max      311230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311230
Ave neighs/atom = 77.807500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.374565820432, Press = 0.206970881799804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  121000   -13873.914   -13873.914   -14019.135   -14019.135    280.94049    280.94049    48050.597    48050.597    336.51316    336.51316 
  122000   -13875.917   -13875.917   -14018.239   -14018.239    275.33029    275.33029    48043.718    48043.718    577.05847    577.05847 
Loop time of 77.7897 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.608 hours/ns, 12.855 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    | 77.423     | 77.423     | 77.423     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046498   | 0.046498   | 0.046498   |   0.0 |  0.06
Output  | 0.00010305 | 0.00010305 | 0.00010305 |   0.0 |  0.00
Modify  | 0.27782    | 0.27782    | 0.27782    |   0.0 |  0.36
Other   |            | 0.0421     |            |       |  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:      311232.0 ave      311232 max      311232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311232
Ave neighs/atom = 77.808000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386516282775, Press = -0.106418263650907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  122000   -13875.917   -13875.917   -14018.239   -14018.239    275.33029    275.33029    48043.718    48043.718    577.05847    577.05847 
  123000   -13873.008   -13873.008   -14016.164   -14016.164    276.94537    276.94537    48157.275    48157.275   -2530.3292   -2530.3292 
Loop time of 77.7663 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.602 hours/ns, 12.859 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    | 77.399     | 77.399     | 77.399     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046459   | 0.046459   | 0.046459   |   0.0 |  0.06
Output  | 0.00010175 | 0.00010175 | 0.00010175 |   0.0 |  0.00
Modify  | 0.27812    | 0.27812    | 0.27812    |   0.0 |  0.36
Other   |            | 0.04216    |            |       |  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:      311210.0 ave      311210 max      311210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311210
Ave neighs/atom = 77.802500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384838306044, Press = -0.288332333094621
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  123000   -13873.008   -13873.008   -14016.164   -14016.164    276.94537    276.94537    48157.275    48157.275   -2530.3292   -2530.3292 
  124000    -13877.68    -13877.68   -14018.227   -14018.227    271.89748    271.89748     48125.68     48125.68   -1836.4073   -1836.4073 
Loop time of 77.7539 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.598 hours/ns, 12.861 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    | 77.387     | 77.387     | 77.387     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046326   | 0.046326   | 0.046326   |   0.0 |  0.06
Output  | 0.00010508 | 0.00010508 | 0.00010508 |   0.0 |  0.00
Modify  | 0.278      | 0.278      | 0.278      |   0.0 |  0.36
Other   |            | 0.04199    |            |       |  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:      311090.0 ave      311090 max      311090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311090
Ave neighs/atom = 77.772500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.392276416617, Press = 0.546913740473232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  124000    -13877.68    -13877.68   -14018.227   -14018.227    271.89748    271.89748     48125.68     48125.68   -1836.4073   -1836.4073 
  125000   -13873.306   -13873.306    -14016.81    -14016.81    277.61808    277.61808    48052.981    48052.981    536.62155    536.62155 
Loop time of 77.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.606 hours/ns, 12.857 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    | 77.413     | 77.413     | 77.413     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046391   | 0.046391   | 0.046391   |   0.0 |  0.06
Output  | 0.00010363 | 0.00010363 | 0.00010363 |   0.0 |  0.00
Modify  | 0.2783     | 0.2783     | 0.2783     |   0.0 |  0.36
Other   |            | 0.04206    |            |       |  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:      311074.0 ave      311074 max      311074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311074
Ave neighs/atom = 77.768500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396794063044, Press = 0.49045188242355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  125000   -13873.306   -13873.306    -14016.81    -14016.81    277.61808    277.61808    48052.981    48052.981    536.62155    536.62155 
  126000   -13875.932   -13875.932    -14019.08    -14019.08    276.92918    276.92918    48020.669    48020.669    1161.7962    1161.7962 
Loop time of 77.7826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.606 hours/ns, 12.856 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.416     | 77.416     | 77.416     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046579   | 0.046579   | 0.046579   |   0.0 |  0.06
Output  | 0.00010298 | 0.00010298 | 0.00010298 |   0.0 |  0.00
Modify  | 0.27822    | 0.27822    | 0.27822    |   0.0 |  0.36
Other   |            | 0.04215    |            |       |  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:      311214.0 ave      311214 max      311214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311214
Ave neighs/atom = 77.803500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396571847427, Press = 0.040499051876759
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  126000   -13875.932   -13875.932    -14019.08    -14019.08    276.92918    276.92918    48020.669    48020.669    1161.7962    1161.7962 
  127000   -13875.635   -13875.635   -14015.406   -14015.406    270.39734    270.39734    48073.893    48073.893    88.377758    88.377758 
Loop time of 77.7381 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.594 hours/ns, 12.864 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    | 77.371     | 77.371     | 77.371     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04646    | 0.04646    | 0.04646    |   0.0 |  0.06
Output  | 0.000103   | 0.000103   | 0.000103   |   0.0 |  0.00
Modify  | 0.27798    | 0.27798    | 0.27798    |   0.0 |  0.36
Other   |            | 0.04215    |            |       |  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:      311164.0 ave      311164 max      311164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311164
Ave neighs/atom = 77.791000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.396286666201, Press = -0.198629094300009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  127000   -13875.635   -13875.635   -14015.406   -14015.406    270.39734    270.39734    48073.893    48073.893    88.377758    88.377758 
  128000   -13873.825   -13873.825   -14015.691   -14015.691    274.45033    274.45033    48106.854    48106.854   -1048.7914   -1048.7914 
Loop time of 77.9109 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.642 hours/ns, 12.835 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    | 77.544     | 77.544     | 77.544     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046668   | 0.046668   | 0.046668   |   0.0 |  0.06
Output  | 0.00010419 | 0.00010419 | 0.00010419 |   0.0 |  0.00
Modify  | 0.27797    | 0.27797    | 0.27797    |   0.0 |  0.36
Other   |            | 0.04209    |            |       |  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:      311194.0 ave      311194 max      311194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311194
Ave neighs/atom = 77.798500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.401558320586, Press = 0.0786446569362305
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  128000   -13873.825   -13873.825   -14015.691   -14015.691    274.45033    274.45033    48106.854    48106.854   -1048.7914   -1048.7914 
  129000   -13878.853   -13878.853   -14017.182   -14017.182    267.60819    267.60819    48065.968    48065.968    46.887538    46.887538 
Loop time of 77.7461 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.596 hours/ns, 12.862 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    | 77.38      | 77.38      | 77.38      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046484   | 0.046484   | 0.046484   |   0.0 |  0.06
Output  | 0.00010078 | 0.00010078 | 0.00010078 |   0.0 |  0.00
Modify  | 0.27786    | 0.27786    | 0.27786    |   0.0 |  0.36
Other   |            | 0.04198    |            |       |  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:      311058.0 ave      311058 max      311058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311058
Ave neighs/atom = 77.764500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.40727820543, Press = 0.232998546657295
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  129000   -13878.853   -13878.853   -14017.182   -14017.182    267.60819    267.60819    48065.968    48065.968    46.887538    46.887538 
  130000   -13874.133   -13874.133   -14016.833   -14016.833    276.06294    276.06294     48060.99     48060.99    268.17156    268.17156 
Loop time of 77.7941 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.609 hours/ns, 12.854 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    | 77.428     | 77.428     | 77.428     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046543   | 0.046543   | 0.046543   |   0.0 |  0.06
Output  | 0.00010325 | 0.00010325 | 0.00010325 |   0.0 |  0.00
Modify  | 0.27781    | 0.27781    | 0.27781    |   0.0 |  0.36
Other   |            | 0.0421     |            |       |  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:      311366.0 ave      311366 max      311366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311366
Ave neighs/atom = 77.841500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404977362752, Press = 0.107903446020263
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  130000   -13874.133   -13874.133   -14016.833   -14016.833    276.06294    276.06294     48060.99     48060.99    268.17156    268.17156 
  131000   -13882.588   -13882.588   -14021.557   -14021.557    268.84528    268.84528    48055.389    48055.389   -149.04295   -149.04295 
Loop time of 77.8068 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.613 hours/ns, 12.852 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    | 77.44      | 77.44      | 77.44      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046447   | 0.046447   | 0.046447   |   0.0 |  0.06
Output  | 0.00010383 | 0.00010383 | 0.00010383 |   0.0 |  0.00
Modify  | 0.27779    | 0.27779    | 0.27779    |   0.0 |  0.36
Other   |            | 0.04194    |            |       |  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:      311230.0 ave      311230 max      311230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311230
Ave neighs/atom = 77.807500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.399487450769, Press = -0.0133369011782895
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  131000   -13882.588   -13882.588   -14021.557   -14021.557    268.84528    268.84528    48055.389    48055.389   -149.04295   -149.04295 
  132000   -13873.505   -13873.505   -14016.375   -14016.375    276.39094    276.39094    48091.349    48091.349   -538.09455   -538.09455 
Loop time of 77.7471 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.596 hours/ns, 12.862 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    | 77.381     | 77.381     | 77.381     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046411   | 0.046411   | 0.046411   |   0.0 |  0.06
Output  | 0.00010513 | 0.00010513 | 0.00010513 |   0.0 |  0.00
Modify  | 0.27793    | 0.27793    | 0.27793    |   0.0 |  0.36
Other   |            | 0.04213    |            |       |  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:      311316.0 ave      311316 max      311316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311316
Ave neighs/atom = 77.829000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384739082491, Press = 0.022211931732185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  132000   -13873.505   -13873.505   -14016.375   -14016.375    276.39094    276.39094    48091.349    48091.349   -538.09455   -538.09455 
  133000   -13876.644   -13876.644   -14017.764   -14017.764    273.00609    273.00609    48099.702    48099.702   -978.44248   -978.44248 
Loop time of 77.6945 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.582 hours/ns, 12.871 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    | 77.328     | 77.328     | 77.328     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046538   | 0.046538   | 0.046538   |   0.0 |  0.06
Output  | 8.8755e-05 | 8.8755e-05 | 8.8755e-05 |   0.0 |  0.00
Modify  | 0.27779    | 0.27779    | 0.27779    |   0.0 |  0.36
Other   |            | 0.04217    |            |       |  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:      311138.0 ave      311138 max      311138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311138
Ave neighs/atom = 77.784500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380893229506, Press = 0.356042007413164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  133000   -13876.644   -13876.644   -14017.764   -14017.764    273.00609    273.00609    48099.702    48099.702   -978.44248   -978.44248 
  134000   -13872.398   -13872.398   -14014.189   -14014.189     274.3059     274.3059    48016.707    48016.707    1812.7196    1812.7196 
Loop time of 77.8822 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.634 hours/ns, 12.840 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    | 77.516     | 77.516     | 77.516     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04647    | 0.04647    | 0.04647    |   0.0 |  0.06
Output  | 0.00011015 | 0.00011015 | 0.00011015 |   0.0 |  0.00
Modify  | 0.27776    | 0.27776    | 0.27776    |   0.0 |  0.36
Other   |            | 0.04209    |            |       |  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:      311178.0 ave      311178 max      311178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311178
Ave neighs/atom = 77.794500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.376397961784, Press = 0.364549156283451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  134000   -13872.398   -13872.398   -14014.189   -14014.189     274.3059     274.3059    48016.707    48016.707    1812.7196    1812.7196 
  135000   -13877.396   -13877.396   -14016.344   -14016.344    268.80439    268.80439    48044.473    48044.473    836.16781    836.16781 
Loop time of 77.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.590 hours/ns, 12.866 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    | 77.356     | 77.356     | 77.356     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046507   | 0.046507   | 0.046507   |   0.0 |  0.06
Output  | 0.00010613 | 0.00010613 | 0.00010613 |   0.0 |  0.00
Modify  | 0.27807    | 0.27807    | 0.27807    |   0.0 |  0.36
Other   |            | 0.04204    |            |       |  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:      311254.0 ave      311254 max      311254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311254
Ave neighs/atom = 77.813500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.374444263314, Press = -0.109276590522009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  135000   -13877.396   -13877.396   -14016.344   -14016.344    268.80439    268.80439    48044.473    48044.473    836.16781    836.16781 
  136000   -13873.936   -13873.936   -14015.036   -14015.036    272.96832    272.96832    48085.428    48085.428   -252.67615   -252.67615 
Loop time of 77.6984 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.583 hours/ns, 12.870 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    | 77.332     | 77.332     | 77.332     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046363   | 0.046363   | 0.046363   |   0.0 |  0.06
Output  | 0.00010393 | 0.00010393 | 0.00010393 |   0.0 |  0.00
Modify  | 0.27784    | 0.27784    | 0.27784    |   0.0 |  0.36
Other   |            | 0.04217    |            |       |  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:      311278.0 ave      311278 max      311278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311278
Ave neighs/atom = 77.819500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.359285172883, Press = -0.0266189397569729
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  136000   -13873.936   -13873.936   -14015.036   -14015.036    272.96832    272.96832    48085.428    48085.428   -252.67615   -252.67615 
  137000   -13876.974   -13876.974   -14018.106   -14018.106    273.03067    273.03067    48074.091    48074.091   -231.31796   -231.31796 
Loop time of 77.7721 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.111 ns/day, 21.603 hours/ns, 12.858 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    | 77.406     | 77.406     | 77.406     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046545   | 0.046545   | 0.046545   |   0.0 |  0.06
Output  | 0.00010431 | 0.00010431 | 0.00010431 |   0.0 |  0.00
Modify  | 0.27795    | 0.27795    | 0.27795    |   0.0 |  0.36
Other   |            | 0.042      |            |       |  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:      311172.0 ave      311172 max      311172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311172
Ave neighs/atom = 77.793000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.356205607251, Press = 0.164219466150731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  137000   -13876.974   -13876.974   -14018.106   -14018.106    273.03067    273.03067    48074.091    48074.091   -231.31796   -231.31796 
  138000   -13874.684   -13874.684   -14016.611   -14016.611    274.56808    274.56808    48072.717    48072.717   -77.937347   -77.937347 
Loop time of 77.8132 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.615 hours/ns, 12.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.447     | 77.447     | 77.447     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046181   | 0.046181   | 0.046181   |   0.0 |  0.06
Output  | 0.00012407 | 0.00012407 | 0.00012407 |   0.0 |  0.00
Modify  | 0.27775    | 0.27775    | 0.27775    |   0.0 |  0.36
Other   |            | 0.04201    |            |       |  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:      311230.0 ave      311230 max      311230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311230
Ave neighs/atom = 77.807500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.358215834765, Press = 0.0834603678015525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.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 
  138000   -13874.684   -13874.684   -14016.611   -14016.611    274.56808    274.56808    48072.717    48072.717   -77.937347   -77.937347 
  139000   -13874.978   -13874.978   -14014.302   -14014.302    269.53198    269.53198    48070.763    48070.763    79.722405    79.722405 
Loop time of 77.7294 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.112 ns/day, 21.592 hours/ns, 12.865 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    | 77.363     | 77.363     | 77.363     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046364   | 0.046364   | 0.046364   |   0.0 |  0.06
Output  | 0.00010469 | 0.00010469 | 0.00010469 |   0.0 |  0.00
Modify  | 0.27783    | 0.27783    | 0.27783    |   0.0 |  0.36
Other   |            | 0.04214    |            |       |  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:      311210.0 ave      311210 max      311210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311210
Ave neighs/atom = 77.802500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
48068.2143712334

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0