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

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

kim_interactions Ni

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

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


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17669.144     -17669.144     -17800         -17800          253.15         253.15         43665.961      43665.961      3200.9264      3200.9264    
      1000  -17530.052     -17530.052     -17669.246     -17669.246      269.2798       269.2798       44119.751      44119.751     -2096.6759     -2096.6759    
Loop time of 79.5785 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.086 ns/day, 22.105 hours/ns, 12.566 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.427     | 79.427     | 79.427     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022377   | 0.022377   | 0.022377   |   0.0 |  0.03
Output  | 0.00015049 | 0.00015049 | 0.00015049 |   0.0 |  0.00
Modify  | 0.11802    | 0.11802    | 0.11802    |   0.0 |  0.15
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       344000 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17530.052     -17530.052     -17669.246     -17669.246      269.2798       269.2798       44119.751      44119.751     -2096.6759     -2096.6759    
      2000  -17537.888     -17537.888     -17664.288     -17664.288      244.53027      244.53027      44045.738      44045.738      1126.0712      1126.0712    
Loop time of 86.5766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.049 hours/ns, 11.550 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.427     | 86.427     | 86.427     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021672   | 0.021672   | 0.021672   |   0.0 |  0.03
Output  | 8.0641e-05 | 8.0641e-05 | 8.0641e-05 |   0.0 |  0.00
Modify  | 0.117      | 0.117      | 0.117      |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       355744 ave      355744 max      355744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 355744
Ave neighs/atom = 88.936
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17537.888     -17537.888     -17664.288     -17664.288      244.53027      244.53027      44045.738      44045.738      1126.0712      1126.0712    
      3000  -17537.656     -17537.656     -17671.158     -17671.158      258.26918      258.26918      44068.913      44068.913     -350.38064     -350.38064    
Loop time of 86.7678 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.996 ns/day, 24.102 hours/ns, 11.525 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.619     | 86.619     | 86.619     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021543   | 0.021543   | 0.021543   |   0.0 |  0.02
Output  | 6.8859e-05 | 6.8859e-05 | 6.8859e-05 |   0.0 |  0.00
Modify  | 0.11708    | 0.11708    | 0.11708    |   0.0 |  0.13
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358696 ave      358696 max      358696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358696
Ave neighs/atom = 89.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17537.656     -17537.656     -17671.158     -17671.158      258.26918      258.26918      44068.913      44068.913     -350.38064     -350.38064    
      4000  -17534.98      -17534.98      -17663.149     -17663.149      247.95051      247.95051      44087.799      44087.799     -413.54474     -413.54474    
Loop time of 86.4448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.012 hours/ns, 11.568 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.295     | 86.295     | 86.295     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02168    | 0.02168    | 0.02168    |   0.0 |  0.03
Output  | 8.9347e-05 | 8.9347e-05 | 8.9347e-05 |   0.0 |  0.00
Modify  | 0.11727    | 0.11727    | 0.11727    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356976 ave      356976 max      356976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356976
Ave neighs/atom = 89.244
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17534.98      -17534.98      -17663.149     -17663.149      247.95051      247.95051      44087.799      44087.799     -413.54474     -413.54474    
      5000  -17539.002     -17539.002     -17671.496     -17671.496      256.31821      256.31821      44027.051      44027.051      1393.75        1393.75      
Loop time of 86.4994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.028 hours/ns, 11.561 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.35      | 86.35      | 86.35      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021568   | 0.021568   | 0.021568   |   0.0 |  0.02
Output  | 5.5634e-05 | 5.5634e-05 | 5.5634e-05 |   0.0 |  0.00
Modify  | 0.11756    | 0.11756    | 0.11756    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357702 ave      357702 max      357702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357702
Ave neighs/atom = 89.4255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.284757377418, Press = -435.488930218816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17539.002     -17539.002     -17671.496     -17671.496      256.31821      256.31821      44027.051      44027.051      1393.75        1393.75      
      6000  -17533.985     -17533.985     -17662.784     -17662.784      249.17045      249.17045      44106.451      44106.451     -1185.602      -1185.602     
Loop time of 86.6649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.074 hours/ns, 11.539 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.512     | 86.512     | 86.512     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021635   | 0.021635   | 0.021635   |   0.0 |  0.02
Output  | 6.8709e-05 | 6.8709e-05 | 6.8709e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357336 ave      357336 max      357336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357336
Ave neighs/atom = 89.334
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.725138296816, Press = -40.6469470802283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17533.985     -17533.985     -17662.784     -17662.784      249.17045      249.17045      44106.451      44106.451     -1185.602      -1185.602     
      7000  -17538.768     -17538.768     -17669.221     -17669.221      252.37017      252.37017      44046.974      44046.974      756.82904      756.82904    
Loop time of 86.6016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.056 hours/ns, 11.547 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.448     | 86.448     | 86.448     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021624   | 0.021624   | 0.021624   |   0.0 |  0.02
Output  | 5.4743e-05 | 5.4743e-05 | 5.4743e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357580 ave      357580 max      357580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357580
Ave neighs/atom = 89.395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.060170396386, Press = -3.73816107587922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17538.768     -17538.768     -17669.221     -17669.221      252.37017      252.37017      44046.974      44046.974      756.82904      756.82904    
      8000  -17536.457     -17536.457     -17668.808     -17668.808      256.04196      256.04196      44062.52       44062.52       135.07685      135.07685    
Loop time of 86.6758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.077 hours/ns, 11.537 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.523     | 86.523     | 86.523     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021712   | 0.021712   | 0.021712   |   0.0 |  0.03
Output  | 5.9862e-05 | 5.9862e-05 | 5.9862e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357610 ave      357610 max      357610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357610
Ave neighs/atom = 89.4025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.027218185013, Press = -24.3432524167178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17536.457     -17536.457     -17668.808     -17668.808      256.04196      256.04196      44062.52       44062.52       135.07685      135.07685    
      9000  -17532.529     -17532.529     -17663.827     -17663.827      254.00521      254.00521      44105.93       44105.93      -1196.9187     -1196.9187    
Loop time of 86.5356 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.038 hours/ns, 11.556 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.382     | 86.382     | 86.382     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021717   | 0.021717   | 0.021717   |   0.0 |  0.03
Output  | 6.6455e-05 | 6.6455e-05 | 6.6455e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.14
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356838 ave      356838 max      356838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356838
Ave neighs/atom = 89.2095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.295029160052, Press = -2.20878747540268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17532.529     -17532.529     -17663.827     -17663.827      254.00521      254.00521      44105.93       44105.93      -1196.9187     -1196.9187    
     10000  -17539.436     -17539.436     -17666.483     -17666.483      245.78128      245.78128      43995.055      43995.055      3099.3444      3099.3444    
Loop time of 86.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.063 hours/ns, 11.544 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.475     | 86.475     | 86.475     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021648   | 0.021648   | 0.021648   |   0.0 |  0.02
Output  | 5.855e-05  | 5.855e-05  | 5.855e-05  |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357318 ave      357318 max      357318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357318
Ave neighs/atom = 89.3295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.449205750834, Press = -6.80980787479446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17539.436     -17539.436     -17666.483     -17666.483      245.78128      245.78128      43995.055      43995.055      3099.3444      3099.3444    
     11000  -17534.459     -17534.459     -17663.867     -17663.867      250.34765      250.34765      44114.777      44114.777     -1530.0905     -1530.0905    
Loop time of 86.7154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.996 ns/day, 24.088 hours/ns, 11.532 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.562     | 86.562     | 86.562     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021675   | 0.021675   | 0.021675   |   0.0 |  0.02
Output  | 6.412e-05  | 6.412e-05  | 6.412e-05  |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.14
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358624 ave      358624 max      358624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358624
Ave neighs/atom = 89.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.564123035719, Press = -10.7705479165805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17534.459     -17534.459     -17663.867     -17663.867      250.34765      250.34765      44114.777      44114.777     -1530.0905     -1530.0905    
     12000  -17535.964     -17535.964     -17670.04      -17670.04       259.37959      259.37959      44061.9        44061.9        104.19156      104.19156    
Loop time of 86.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.026 hours/ns, 11.561 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.342     | 86.342     | 86.342     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021587   | 0.021587   | 0.021587   |   0.0 |  0.02
Output  | 5.1857e-05 | 5.1857e-05 | 5.1857e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357228 ave      357228 max      357228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357228
Ave neighs/atom = 89.307
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.548091789364, Press = -0.879058707398245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17535.964     -17535.964     -17670.04      -17670.04       259.37959      259.37959      44061.9        44061.9        104.19156      104.19156    
     13000  -17536.543     -17536.543     -17666.823     -17666.823      252.03633      252.03633      44062.461      44062.461      327.41571      327.41571    
Loop time of 86.6378 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.066 hours/ns, 11.542 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.485     | 86.485     | 86.485     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021638   | 0.021638   | 0.021638   |   0.0 |  0.02
Output  | 6.1605e-05 | 6.1605e-05 | 6.1605e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357484 ave      357484 max      357484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357484
Ave neighs/atom = 89.371
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.757004692958, Press = -7.73232925800673
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17536.543     -17536.543     -17666.823     -17666.823      252.03633      252.03633      44062.461      44062.461      327.41571      327.41571    
     14000  -17535.415     -17535.415     -17667.44      -17667.44       255.4112       255.4112       44087.214      44087.214     -716.67131     -716.67131    
Loop time of 86.6325 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.065 hours/ns, 11.543 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.479     | 86.479     | 86.479     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021696   | 0.021696   | 0.021696   |   0.0 |  0.03
Output  | 5.5755e-05 | 5.5755e-05 | 5.5755e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357478 ave      357478 max      357478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357478
Ave neighs/atom = 89.3695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.684851676235, Press = -2.63592891779343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17535.415     -17535.415     -17667.44      -17667.44       255.4112       255.4112       44087.214      44087.214     -716.67131     -716.67131    
     15000  -17537.851     -17537.851     -17668.151     -17668.151      252.07404      252.07404      44016.981      44016.981      2044.1028      2044.1028    
Loop time of 86.4801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.022 hours/ns, 11.563 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.327     | 86.327     | 86.327     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021596   | 0.021596   | 0.021596   |   0.0 |  0.02
Output  | 6.1526e-05 | 6.1526e-05 | 6.1526e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356970 ave      356970 max      356970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356970
Ave neighs/atom = 89.2425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.61581675197, Press = -5.04501552111232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17537.851     -17537.851     -17668.151     -17668.151      252.07404      252.07404      44016.981      44016.981      2044.1028      2044.1028    
     16000  -17534.856     -17534.856     -17665.148     -17665.148      252.05845      252.05845      44146.841      44146.841     -2984.3693     -2984.3693    
Loop time of 86.6745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.076 hours/ns, 11.537 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.521     | 86.521     | 86.521     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.03
Output  | 4.8671e-05 | 4.8671e-05 | 4.8671e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357904 ave      357904 max      357904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357904
Ave neighs/atom = 89.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.573878603778, Press = -5.53129745648762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17534.856     -17534.856     -17665.148     -17665.148      252.05845      252.05845      44146.841      44146.841     -2984.3693     -2984.3693    
     17000  -17538.853     -17538.853     -17671.346     -17671.346      256.31669      256.31669      44030.779      44030.779      1159.7327      1159.7327    
Loop time of 86.4314 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.009 hours/ns, 11.570 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.278     | 86.278     | 86.278     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021675   | 0.021675   | 0.021675   |   0.0 |  0.03
Output  | 5.9632e-05 | 5.9632e-05 | 5.9632e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356148 ave      356148 max      356148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356148
Ave neighs/atom = 89.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.571290875027, Press = 0.537287421206607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17538.853     -17538.853     -17671.346     -17671.346      256.31669      256.31669      44030.779      44030.779      1159.7327      1159.7327    
     18000  -17534.229     -17534.229     -17665.917     -17665.917      254.75852      254.75852      44077.707      44077.707     -217.95367     -217.95367    
Loop time of 86.6315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.064 hours/ns, 11.543 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.478     | 86.478     | 86.478     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021675   | 0.021675   | 0.021675   |   0.0 |  0.03
Output  | 6.2297e-05 | 6.2297e-05 | 6.2297e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357854 ave      357854 max      357854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357854
Ave neighs/atom = 89.4635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.519997122067, Press = -4.60132280462247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17534.229     -17534.229     -17665.917     -17665.917      254.75852      254.75852      44077.707      44077.707     -217.95367     -217.95367    
     19000  -17538.41      -17538.41      -17667.069     -17667.069      248.89929      248.89929      44082.017      44082.017     -625.44068     -625.44068    
Loop time of 86.5551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.043 hours/ns, 11.553 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.402     | 86.402     | 86.402     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02173    | 0.02173    | 0.02173    |   0.0 |  0.03
Output  | 6.1506e-05 | 6.1506e-05 | 6.1506e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357648 ave      357648 max      357648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357648
Ave neighs/atom = 89.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.524065636538, Press = -1.32809885773042
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17538.41      -17538.41      -17667.069     -17667.069      248.89929      248.89929      44082.017      44082.017     -625.44068     -625.44068    
     20000  -17536.136     -17536.136     -17664.093     -17664.093      247.54238      247.54238      44047.342      44047.342      1104.0316      1104.0316    
Loop time of 86.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.004 hours/ns, 11.572 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.261     | 86.261     | 86.261     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021593   | 0.021593   | 0.021593   |   0.0 |  0.02
Output  | 6.5714e-05 | 6.5714e-05 | 6.5714e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357266 ave      357266 max      357266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357266
Ave neighs/atom = 89.3165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.489497074808, Press = -2.76028721856413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17536.136     -17536.136     -17664.093     -17664.093      247.54238      247.54238      44047.342      44047.342      1104.0316      1104.0316    
     21000  -17540.589     -17540.589     -17670.357     -17670.357      251.04617      251.04617      44112.826      44112.826     -2165.2234     -2165.2234    
Loop time of 86.5038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.029 hours/ns, 11.560 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.351     | 86.351     | 86.351     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021601   | 0.021601   | 0.021601   |   0.0 |  0.02
Output  | 5.0685e-05 | 5.0685e-05 | 5.0685e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358674 ave      358674 max      358674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358674
Ave neighs/atom = 89.6685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.397441535268, Press = -3.4626200289063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17540.589     -17540.589     -17670.357     -17670.357      251.04617      251.04617      44112.826      44112.826     -2165.2234     -2165.2234    
     22000  -17533.507     -17533.507     -17664.623     -17664.623      253.65288      253.65288      44032.278      44032.278      1770.0381      1770.0381    
Loop time of 86.1878 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.002 ns/day, 23.941 hours/ns, 11.603 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.035     | 86.035     | 86.035     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021555   | 0.021555   | 0.021555   |   0.0 |  0.03
Output  | 6.0774e-05 | 6.0774e-05 | 6.0774e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356396 ave      356396 max      356396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356396
Ave neighs/atom = 89.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.375023586465, Press = 1.22434222691393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17533.507     -17533.507     -17664.623     -17664.623      253.65288      253.65288      44032.278      44032.278      1770.0381      1770.0381    
     23000  -17538.949     -17538.949     -17670.257     -17670.257      254.02279      254.02279      44063.687      44063.687     -118.15612     -118.15612    
Loop time of 86.6332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.065 hours/ns, 11.543 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.48      | 86.48      | 86.48      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021752   | 0.021752   | 0.021752   |   0.0 |  0.03
Output  | 4.8601e-05 | 4.8601e-05 | 4.8601e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.14
Other   |            | 0.0106     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358722 ave      358722 max      358722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358722
Ave neighs/atom = 89.6805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.431839805609, Press = -4.13317101791384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17538.949     -17538.949     -17670.257     -17670.257      254.02279      254.02279      44063.687      44063.687     -118.15612     -118.15612    
     24000  -17536.772     -17536.772     -17668.354     -17668.354      254.55327      254.55327      44089.035      44089.035     -942.28543     -942.28543    
Loop time of 86.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.043 hours/ns, 11.553 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.401     | 86.401     | 86.401     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021591   | 0.021591   | 0.021591   |   0.0 |  0.02
Output  | 6.1415e-05 | 6.1415e-05 | 6.1415e-05 |   0.0 |  0.00
Modify  | 0.12082    | 0.12082    | 0.12082    |   0.0 |  0.14
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357180 ave      357180 max      357180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357180
Ave neighs/atom = 89.295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.433340715405, Press = -1.05355733034463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17536.772     -17536.772     -17668.354     -17668.354      254.55327      254.55327      44089.035      44089.035     -942.28543     -942.28543    
     25000  -17537.396     -17537.396     -17669.377     -17669.377      255.32564      255.32564      44039.737      44039.737      965.93632      965.93632    
Loop time of 86.4538 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.015 hours/ns, 11.567 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.301     | 86.301     | 86.301     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.03
Output  | 4.3732e-05 | 4.3732e-05 | 4.3732e-05 |   0.0 |  0.00
Modify  | 0.1208     | 0.1208     | 0.1208     |   0.0 |  0.14
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356898 ave      356898 max      356898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356898
Ave neighs/atom = 89.2245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.40149464128, Press = -1.30841985834715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17537.396     -17537.396     -17669.377     -17669.377      255.32564      255.32564      44039.737      44039.737      965.93632      965.93632    
     26000  -17538.443     -17538.443     -17668.659     -17668.659      251.91285      251.91285      44090.558      44090.558     -1114.8107     -1114.8107    
Loop time of 86.4651 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.018 hours/ns, 11.565 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.312     | 86.312     | 86.312     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021667   | 0.021667   | 0.021667   |   0.0 |  0.03
Output  | 5.3471e-05 | 5.3471e-05 | 5.3471e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357974 ave      357974 max      357974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357974
Ave neighs/atom = 89.4935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.432759614692, Press = -2.87877134867087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17538.443     -17538.443     -17668.659     -17668.659      251.91285      251.91285      44090.558      44090.558     -1114.8107     -1114.8107    
     27000  -17536.577     -17536.577     -17666.826     -17666.826      251.97545      251.97545      44066.895      44066.895      132.54633      132.54633    
Loop time of 86.4721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.020 hours/ns, 11.564 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.319     | 86.319     | 86.319     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021639   | 0.021639   | 0.021639   |   0.0 |  0.03
Output  | 5.7788e-05 | 5.7788e-05 | 5.7788e-05 |   0.0 |  0.00
Modify  | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357224 ave      357224 max      357224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357224
Ave neighs/atom = 89.306
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.439615587912, Press = -0.0321683902063205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17536.577     -17536.577     -17666.826     -17666.826      251.97545      251.97545      44066.895      44066.895      132.54633      132.54633    
     28000  -17540.437     -17540.437     -17668.291     -17668.291      247.34147      247.34147      44041.511      44041.511      945.61906      945.61906    
Loop time of 86.574 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.048 hours/ns, 11.551 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.421     | 86.421     | 86.421     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021609   | 0.021609   | 0.021609   |   0.0 |  0.02
Output  | 5.2087e-05 | 5.2087e-05 | 5.2087e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357454 ave      357454 max      357454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357454
Ave neighs/atom = 89.3635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.403992586505, Press = -2.8880203324878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17540.437     -17540.437     -17668.291     -17668.291      247.34147      247.34147      44041.511      44041.511      945.61906      945.61906    
     29000  -17535.911     -17535.911     -17666.182     -17666.182      252.01872      252.01872      44113.264      44113.264     -1711.7343     -1711.7343    
Loop time of 86.5823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.051 hours/ns, 11.550 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.429     | 86.429     | 86.429     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021693   | 0.021693   | 0.021693   |   0.0 |  0.03
Output  | 5.6266e-05 | 5.6266e-05 | 5.6266e-05 |   0.0 |  0.00
Modify  | 0.12089    | 0.12089    | 0.12089    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358010 ave      358010 max      358010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358010
Ave neighs/atom = 89.5025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.379562480831, Press = -0.833239407885136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17535.911     -17535.911     -17666.182     -17666.182      252.01872      252.01872      44113.264      44113.264     -1711.7343     -1711.7343    
     30000  -17538.177     -17538.177     -17668.601     -17668.601      252.31443      252.31443      44012.664      44012.664      2214.9022      2214.9022    
Loop time of 86.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.013 hours/ns, 11.568 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.292     | 86.292     | 86.292     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021618   | 0.021618   | 0.021618   |   0.0 |  0.03
Output  | 4.9883e-05 | 4.9883e-05 | 4.9883e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356770 ave      356770 max      356770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356770
Ave neighs/atom = 89.1925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.301202592044, Press = -0.741825476266612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17538.177     -17538.177     -17668.601     -17668.601      252.31443      252.31443      44012.664      44012.664      2214.9022      2214.9022    
     31000  -17531.497     -17531.497     -17666.078     -17666.078      260.35653      260.35653      44100.628      44100.628     -1093.4266     -1093.4266    
Loop time of 86.7252 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.996 ns/day, 24.090 hours/ns, 11.531 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.572     | 86.572     | 86.572     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021593   | 0.021593   | 0.021593   |   0.0 |  0.02
Output  | 5.9512e-05 | 5.9512e-05 | 5.9512e-05 |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.14
Other   |            | 0.01049    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357984 ave      357984 max      357984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357984
Ave neighs/atom = 89.496
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.322053241206, Press = -1.85752890246886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17531.497     -17531.497     -17666.078     -17666.078      260.35653      260.35653      44100.628      44100.628     -1093.4266     -1093.4266    
     32000  -17538.11      -17538.11      -17668.951     -17668.951      253.11971      253.11971      44063.872      44063.872      55.709134      55.709134    
Loop time of 86.4871 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.024 hours/ns, 11.562 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.334     | 86.334     | 86.334     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021549   | 0.021549   | 0.021549   |   0.0 |  0.02
Output  | 4.7439e-05 | 4.7439e-05 | 4.7439e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356838 ave      356838 max      356838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356838
Ave neighs/atom = 89.2095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.360717444003, Press = -0.205697285724973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17538.11      -17538.11      -17668.951     -17668.951      253.11971      253.11971      44063.872      44063.872      55.709134      55.709134    
     33000  -17535.168     -17535.168     -17664.699     -17664.699      250.58601      250.58601      44064.24       44064.24       514.3955       514.3955     
Loop time of 86.6059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.057 hours/ns, 11.547 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.453     | 86.453     | 86.453     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021589   | 0.021589   | 0.021589   |   0.0 |  0.02
Output  | 6.3499e-05 | 6.3499e-05 | 6.3499e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357424 ave      357424 max      357424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357424
Ave neighs/atom = 89.356
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.406308552615, Press = -2.20686366502955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17535.168     -17535.168     -17664.699     -17664.699      250.58601      250.58601      44064.24       44064.24       514.3955       514.3955     
     34000  -17536.027     -17536.027     -17667.556     -17667.556      254.45201      254.45201      44086.28       44086.28      -767.8494      -767.8494     
Loop time of 86.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.069 hours/ns, 11.541 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.497     | 86.497     | 86.497     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021672   | 0.021672   | 0.021672   |   0.0 |  0.03
Output  | 6.5493e-05 | 6.5493e-05 | 6.5493e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357460 ave      357460 max      357460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357460
Ave neighs/atom = 89.365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.382226620814, Press = -1.02705897423846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17536.027     -17536.027     -17667.556     -17667.556      254.45201      254.45201      44086.28       44086.28      -767.8494      -767.8494     
     35000  -17535.493     -17535.493     -17667.489     -17667.489      255.35569      255.35569      44059.003      44059.003      405.65969      405.65969    
Loop time of 86.5222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.034 hours/ns, 11.558 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.369     | 86.369     | 86.369     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.02
Output  | 5.1617e-05 | 5.1617e-05 | 5.1617e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357276 ave      357276 max      357276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357276
Ave neighs/atom = 89.319
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.379963903964, Press = -1.15175192061159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17535.493     -17535.493     -17667.489     -17667.489      255.35569      255.35569      44059.003      44059.003      405.65969      405.65969    
     36000  -17533.047     -17533.047     -17665.078     -17665.078      255.42368      255.42368      44080.381      44080.381     -120.3664      -120.3664     
Loop time of 86.6836 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.079 hours/ns, 11.536 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.53      | 86.53      | 86.53      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021604   | 0.021604   | 0.021604   |   0.0 |  0.02
Output  | 5.7297e-05 | 5.7297e-05 | 5.7297e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357836 ave      357836 max      357836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357836
Ave neighs/atom = 89.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.365256895388, Press = -1.84894418760037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17533.047     -17533.047     -17665.078     -17665.078      255.42368      255.42368      44080.381      44080.381     -120.3664      -120.3664     
     37000  -17538.027     -17538.027     -17666.109     -17666.109      247.78429      247.78429      44069.629      44069.629      67.210697      67.210697    
Loop time of 86.4943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.026 hours/ns, 11.561 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.341     | 86.341     | 86.341     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021589   | 0.021589   | 0.021589   |   0.0 |  0.02
Output  | 4.9312e-05 | 4.9312e-05 | 4.9312e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357370 ave      357370 max      357370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357370
Ave neighs/atom = 89.3425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.39580627166, Press = -0.861586142143221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17538.027     -17538.027     -17666.109     -17666.109      247.78429      247.78429      44069.629      44069.629      67.210697      67.210697    
     38000  -17536.009     -17536.009     -17666.153     -17666.153      251.77348      251.77348      44054.829      44054.829      700.67854      700.67854    
Loop time of 86.5969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.055 hours/ns, 11.548 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.444     | 86.444     | 86.444     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021684   | 0.021684   | 0.021684   |   0.0 |  0.03
Output  | 0.00012977 | 0.00012977 | 0.00012977 |   0.0 |  0.00
Modify  | 0.12092    | 0.12092    | 0.12092    |   0.0 |  0.14
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357130 ave      357130 max      357130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357130
Ave neighs/atom = 89.2825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.383239273211, Press = -1.28876304575814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17536.009     -17536.009     -17666.153     -17666.153      251.77348      251.77348      44054.829      44054.829      700.67854      700.67854    
     39000  -17534.087     -17534.087     -17669.642     -17669.642      262.24059      262.24059      44109.357      44109.357     -1805.4787     -1805.4787    
Loop time of 86.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.033 hours/ns, 11.558 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.366     | 86.366     | 86.366     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021592   | 0.021592   | 0.021592   |   0.0 |  0.02
Output  | 4.777e-05  | 4.777e-05  | 4.777e-05  |   0.0 |  0.00
Modify  | 0.12088    | 0.12088    | 0.12088    |   0.0 |  0.14
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357488 ave      357488 max      357488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357488
Ave neighs/atom = 89.372
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.375704939834, Press = -1.37889745702783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17534.087     -17534.087     -17669.642     -17669.642      262.24059      262.24059      44109.357      44109.357     -1805.4787     -1805.4787    
     40000  -17537.406     -17537.406     -17668.192     -17668.192      253.01306      253.01306      44038.397      44038.397      1135.9978      1135.9978    
Loop time of 86.4009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.000 hours/ns, 11.574 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.248     | 86.248     | 86.248     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021582   | 0.021582   | 0.021582   |   0.0 |  0.02
Output  | 6.0995e-05 | 6.0995e-05 | 6.0995e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356342 ave      356342 max      356342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356342
Ave neighs/atom = 89.0855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.352515737217, Press = 0.191404071191232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17537.406     -17537.406     -17668.192     -17668.192      253.01306      253.01306      44038.397      44038.397      1135.9978      1135.9978    
     41000  -17538.139     -17538.139     -17668.073     -17668.073      251.3667       251.3667       44067.218      44067.218     -19.667781     -19.667781    
Loop time of 86.5182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.033 hours/ns, 11.558 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.365     | 86.365     | 86.365     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.03
Output  | 4.4604e-05 | 4.4604e-05 | 4.4604e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357932 ave      357932 max      357932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357932
Ave neighs/atom = 89.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.364913848455, Press = -2.46428265426984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17538.139     -17538.139     -17668.073     -17668.073      251.3667       251.3667       44067.218      44067.218     -19.667781     -19.667781    
     42000  -17534.63      -17534.63      -17664.607     -17664.607      251.44926      251.44926      44093.183      44093.183     -800.72549     -800.72549    
Loop time of 86.528 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.036 hours/ns, 11.557 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.375     | 86.375     | 86.375     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02177    | 0.02177    | 0.02177    |   0.0 |  0.03
Output  | 5.1567e-05 | 5.1567e-05 | 5.1567e-05 |   0.0 |  0.00
Modify  | 0.12074    | 0.12074    | 0.12074    |   0.0 |  0.14
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357502 ave      357502 max      357502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357502
Ave neighs/atom = 89.3755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.331920570605, Press = -0.307795295131006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17534.63      -17534.63      -17664.607     -17664.607      251.44926      251.44926      44093.183      44093.183     -800.72549     -800.72549    
     43000  -17540.486     -17540.486     -17671.663     -17671.663      253.77023      253.77023      44046.828      44046.828      442.0362       442.0362     
Loop time of 86.569 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.047 hours/ns, 11.551 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.416     | 86.416     | 86.416     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021591   | 0.021591   | 0.021591   |   0.0 |  0.02
Output  | 5.849e-05  | 5.849e-05  | 5.849e-05  |   0.0 |  0.00
Modify  | 0.12075    | 0.12075    | 0.12075    |   0.0 |  0.14
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357480 ave      357480 max      357480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357480
Ave neighs/atom = 89.37
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.31647949974, Press = -1.04313295918223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17540.486     -17540.486     -17671.663     -17671.663      253.77023      253.77023      44046.828      44046.828      442.0362       442.0362     
     44000  -17535.422     -17535.422     -17667.157     -17667.157      254.84976      254.84976      44078.637      44078.637     -340.78441     -340.78441    
Loop time of 86.3631 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 23.990 hours/ns, 11.579 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.21      | 86.21      | 86.21      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021842   | 0.021842   | 0.021842   |   0.0 |  0.03
Output  | 5.2388e-05 | 5.2388e-05 | 5.2388e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357696 ave      357696 max      357696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357696
Ave neighs/atom = 89.424
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.281481214817, Press = -1.2391831938385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17535.422     -17535.422     -17667.157     -17667.157      254.84976      254.84976      44078.637      44078.637     -340.78441     -340.78441    
     45000  -17541.141     -17541.141     -17668.932     -17668.932      247.21997      247.21997      44047.182      44047.182      641.76156      641.76156    
Loop time of 86.3329 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.001 ns/day, 23.981 hours/ns, 11.583 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.18      | 86.18      | 86.18      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021598   | 0.021598   | 0.021598   |   0.0 |  0.03
Output  | 6.3209e-05 | 6.3209e-05 | 6.3209e-05 |   0.0 |  0.00
Modify  | 0.12076    | 0.12076    | 0.12076    |   0.0 |  0.14
Other   |            | 0.01047    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357322 ave      357322 max      357322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357322
Ave neighs/atom = 89.3305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.23969371328, Press = -0.769974576506881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17541.141     -17541.141     -17668.932     -17668.932      247.21997      247.21997      44047.182      44047.182      641.76156      641.76156    
     46000  -17538.765     -17538.765     -17669.944     -17669.944      253.7728       253.7728       44103.755      44103.755     -1771.0859     -1771.0859    
Loop time of 86.5238 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.034 hours/ns, 11.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.371     | 86.371     | 86.371     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021682   | 0.021682   | 0.021682   |   0.0 |  0.03
Output  | 4.8801e-05 | 4.8801e-05 | 4.8801e-05 |   0.0 |  0.00
Modify  | 0.12087    | 0.12087    | 0.12087    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357762 ave      357762 max      357762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357762
Ave neighs/atom = 89.4405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.236706716297, Press = -2.12701751673778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17538.765     -17538.765     -17669.944     -17669.944      253.7728       253.7728       44103.755      44103.755     -1771.0859     -1771.0859    
     47000  -17532.799     -17532.799     -17664.507     -17664.507      254.7966       254.7966       44062.239      44062.239      476.17653      476.17653    
Loop time of 86.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.001 ns/day, 23.984 hours/ns, 11.582 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.191     | 86.191     | 86.191     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0217     | 0.0217     | 0.0217     |   0.0 |  0.03
Output  | 6.4832e-05 | 6.4832e-05 | 6.4832e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356654 ave      356654 max      356654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356654
Ave neighs/atom = 89.1635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.26389533692, Press = 0.538922640149991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17532.799     -17532.799     -17664.507     -17664.507      254.7966       254.7966       44062.239      44062.239      476.17653      476.17653    
     48000  -17535.433     -17535.433     -17667.677     -17667.677      255.83473      255.83473      44048.694      44048.694      785.90771      785.90771    
Loop time of 86.5152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.032 hours/ns, 11.559 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.362     | 86.362     | 86.362     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.02
Output  | 4.4153e-05 | 4.4153e-05 | 4.4153e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358374 ave      358374 max      358374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358374
Ave neighs/atom = 89.5935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.282292941612, Press = -1.77618068761367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17535.433     -17535.433     -17667.677     -17667.677      255.83473      255.83473      44048.694      44048.694      785.90771      785.90771    
     49000  -17532.538     -17532.538     -17665.308     -17665.308      256.85299      256.85299      44099.703      44099.703     -1034.0847     -1034.0847    
Loop time of 86.5013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.028 hours/ns, 11.561 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.348     | 86.348     | 86.348     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021662   | 0.021662   | 0.021662   |   0.0 |  0.03
Output  | 6.0624e-05 | 6.0624e-05 | 6.0624e-05 |   0.0 |  0.00
Modify  | 0.12079    | 0.12079    | 0.12079    |   0.0 |  0.14
Other   |            | 0.01051    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357886 ave      357886 max      357886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357886
Ave neighs/atom = 89.4715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.281367853361, Press = -0.773779170774985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17532.538     -17532.538     -17665.308     -17665.308      256.85299      256.85299      44099.703      44099.703     -1034.0847     -1034.0847    
     50000  -17537.074     -17537.074     -17667.86      -17667.86       253.01363      253.01363      44045.016      44045.016      985.00337      985.00337    
Loop time of 86.3909 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 23.997 hours/ns, 11.575 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.238     | 86.238     | 86.238     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02154    | 0.02154    | 0.02154    |   0.0 |  0.02
Output  | 5.9451e-05 | 5.9451e-05 | 5.9451e-05 |   0.0 |  0.00
Modify  | 0.12086    | 0.12086    | 0.12086    |   0.0 |  0.14
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357446 ave      357446 max      357446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357446
Ave neighs/atom = 89.3615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.31374021375, Press = -0.457850401783426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17537.074     -17537.074     -17667.86      -17667.86       253.01363      253.01363      44045.016      44045.016      985.00337      985.00337    
     51000  -17532.843     -17532.843     -17666.986     -17666.986      259.51013      259.51013      44083.845      44083.845     -517.6479      -517.6479     
Loop time of 86.6452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.068 hours/ns, 11.541 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.492     | 86.492     | 86.492     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021641   | 0.021641   | 0.021641   |   0.0 |  0.02
Output  | 5.4442e-05 | 5.4442e-05 | 5.4442e-05 |   0.0 |  0.00
Modify  | 0.12085    | 0.12085    | 0.12085    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358108 ave      358108 max      358108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358108
Ave neighs/atom = 89.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.324782218333, Press = -1.19113782364303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17532.843     -17532.843     -17666.986     -17666.986      259.51013      259.51013      44083.845      44083.845     -517.6479      -517.6479     
     52000  -17538.057     -17538.057     -17666.84      -17666.84       249.1401       249.1401       44066.359      44066.359      67.380961      67.380961    
Loop time of 86.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.001 hours/ns, 11.574 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.249     | 86.249     | 86.249     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021609   | 0.021609   | 0.021609   |   0.0 |  0.03
Output  | 6.3299e-05 | 6.3299e-05 | 6.3299e-05 |   0.0 |  0.00
Modify  | 0.12078    | 0.12078    | 0.12078    |   0.0 |  0.14
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357782 ave      357782 max      357782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357782
Ave neighs/atom = 89.4455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.339638853753, Press = -0.64125653471752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17538.057     -17538.057     -17666.84      -17666.84       249.1401       249.1401       44066.359      44066.359      67.380961      67.380961    
     53000  -17540.6       -17540.6       -17669.528     -17669.528      249.41975      249.41975      44053.227      44053.227      310.80309      310.80309    
Loop time of 86.4654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.018 hours/ns, 11.565 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.312     | 86.312     | 86.312     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021621   | 0.021621   | 0.021621   |   0.0 |  0.03
Output  | 5.315e-05  | 5.315e-05  | 5.315e-05  |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357854 ave      357854 max      357854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357854
Ave neighs/atom = 89.4635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.333485439153, Press = -1.05090279285319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17540.6       -17540.6       -17669.528     -17669.528      249.41975      249.41975      44053.227      44053.227      310.80309      310.80309    
     54000  -17535.777     -17535.777     -17666.103     -17666.103      252.12448      252.12448      44076.559      44076.559     -218.84441     -218.84441    
Loop time of 86.468 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.019 hours/ns, 11.565 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.315     | 86.315     | 86.315     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021521   | 0.021521   | 0.021521   |   0.0 |  0.02
Output  | 6.4371e-05 | 6.4371e-05 | 6.4371e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.14
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357440 ave      357440 max      357440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357440
Ave neighs/atom = 89.36
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.29335604853, Press = -0.99086687157723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17535.777     -17535.777     -17666.103     -17666.103      252.12448      252.12448      44076.559      44076.559     -218.84441     -218.84441    
     55000  -17540.725     -17540.725     -17668.715     -17668.715      247.60444      247.60444      44050.965      44050.965      501.77595      501.77595    
Loop time of 86.4843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.999 ns/day, 24.023 hours/ns, 11.563 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.331     | 86.331     | 86.331     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021708   | 0.021708   | 0.021708   |   0.0 |  0.03
Output  | 4.7189e-05 | 4.7189e-05 | 4.7189e-05 |   0.0 |  0.00
Modify  | 0.12097    | 0.12097    | 0.12097    |   0.0 |  0.14
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357458 ave      357458 max      357458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357458
Ave neighs/atom = 89.3645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.267722559938, Press = -0.412521086971685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17540.725     -17540.725     -17668.715     -17668.715      247.60444      247.60444      44050.965      44050.965      501.77595      501.77595    
     56000  -17538.023     -17538.023     -17667.936     -17667.936      251.3247       251.3247       44058.027      44058.027      325.85919      325.85919    
Loop time of 86.6304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.997 ns/day, 24.064 hours/ns, 11.543 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.477     | 86.477     | 86.477     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021571   | 0.021571   | 0.021571   |   0.0 |  0.02
Output  | 5.4593e-05 | 5.4593e-05 | 5.4593e-05 |   0.0 |  0.00
Modify  | 0.12098    | 0.12098    | 0.12098    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357530 ave      357530 max      357530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357530
Ave neighs/atom = 89.3825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.279344337689, Press = -1.48045877589281
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17538.023     -17538.023     -17667.936     -17667.936      251.3247       251.3247       44058.027      44058.027      325.85919      325.85919    
     57000  -17534.431     -17534.431     -17665.994     -17665.994      254.5176       254.5176       44107.769      44107.769     -1466.5102     -1466.5102    
Loop time of 86.6066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.057 hours/ns, 11.546 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.453     | 86.453     | 86.453     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.03
Output  | 4.788e-05  | 4.788e-05  | 4.788e-05  |   0.0 |  0.00
Modify  | 0.12092    | 0.12092    | 0.12092    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357608 ave      357608 max      357608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357608
Ave neighs/atom = 89.402
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.294680260272, Press = -0.241984528651657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17534.431     -17534.431     -17665.994     -17665.994      254.5176       254.5176       44107.769      44107.769     -1466.5102     -1466.5102    
     58000  -17538.201     -17538.201     -17668.527     -17668.527      252.12371      252.12371      44000.138      44000.138      2731.8749      2731.8749    
Loop time of 86.4126 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.003 hours/ns, 11.572 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.259     | 86.259     | 86.259     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021652   | 0.021652   | 0.021652   |   0.0 |  0.03
Output  | 5.5284e-05 | 5.5284e-05 | 5.5284e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  0.14
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357016 ave      357016 max      357016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357016
Ave neighs/atom = 89.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.285847140058, Press = -0.815114311453692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17538.201     -17538.201     -17668.527     -17668.527      252.12371      252.12371      44000.138      44000.138      2731.8749      2731.8749    
     59000  -17536.051     -17536.051     -17668.628     -17668.628      256.4797       256.4797       44101.783      44101.783     -1424.3984     -1424.3984    
Loop time of 86.6141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.059 hours/ns, 11.545 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.461     | 86.461     | 86.461     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021616   | 0.021616   | 0.021616   |   0.0 |  0.02
Output  | 5.859e-05  | 5.859e-05  | 5.859e-05  |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       358490 ave      358490 max      358490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 358490
Ave neighs/atom = 89.6225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.274026965391, Press = -1.23069391501538
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17536.051     -17536.051     -17668.628     -17668.628      256.4797       256.4797       44101.783      44101.783     -1424.3984     -1424.3984    
     60000  -17536.774     -17536.774     -17666.576     -17666.576      251.11057      251.11057      44057.353      44057.353      506.39561      506.39561    
Loop time of 86.3991 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 24.000 hours/ns, 11.574 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.246     | 86.246     | 86.246     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021649   | 0.021649   | 0.021649   |   0.0 |  0.03
Output  | 5.5574e-05 | 5.5574e-05 | 5.5574e-05 |   0.0 |  0.00
Modify  | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.14
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356700 ave      356700 max      356700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356700
Ave neighs/atom = 89.175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.273565607972, Press = -0.399186842449859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17536.774     -17536.774     -17666.576     -17666.576      251.11057      251.11057      44057.353      44057.353      506.39561      506.39561    
     61000  -17537.207     -17537.207     -17667.864     -17667.864      252.76451      252.76451      44056.043      44056.043      456.65915      456.65915    
Loop time of 86.5488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.998 ns/day, 24.041 hours/ns, 11.554 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.396     | 86.396     | 86.396     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021579   | 0.021579   | 0.021579   |   0.0 |  0.02
Output  | 6.1175e-05 | 6.1175e-05 | 6.1175e-05 |   0.0 |  0.00
Modify  | 0.1209     | 0.1209     | 0.1209     |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357928 ave      357928 max      357928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357928
Ave neighs/atom = 89.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.30473320267, Press = -1.08049702510621
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17537.207     -17537.207     -17667.864     -17667.864      252.76451      252.76451      44056.043      44056.043      456.65915      456.65915    
     62000  -17533.604     -17533.604     -17668.221     -17668.221      260.42597      260.42597      44110.558      44110.558     -1753.9816     -1753.9816    
Loop time of 86.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 23.998 hours/ns, 11.575 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.241     | 86.241     | 86.241     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02167    | 0.02167    | 0.02167    |   0.0 |  0.03
Output  | 5.3059e-05 | 5.3059e-05 | 5.3059e-05 |   0.0 |  0.00
Modify  | 0.12091    | 0.12091    | 0.12091    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       357798 ave      357798 max      357798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 357798
Ave neighs/atom = 89.4495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.310439576696, Press = -0.808969150997983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.607 | 4.607 | 4.607 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17533.604     -17533.604     -17668.221     -17668.221      260.42597      260.42597      44110.558      44110.558     -1753.9816     -1753.9816    
     63000  -17539.88      -17539.88      -17669.125     -17669.125      250.03294      250.03294      44006.195      44006.195      2450.1722      2450.1722    
Loop time of 86.3688 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.000 ns/day, 23.991 hours/ns, 11.578 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 86.216     | 86.216     | 86.216     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.03
Output  | 5.4813e-05 | 5.4813e-05 | 5.4813e-05 |   0.0 |  0.00
Modify  | 0.12095    | 0.12095    | 0.12095    |   0.0 |  0.14
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       356530 ave      356530 max      356530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 356530
Ave neighs/atom = 89.1325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
44067.9961182703

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0