# 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.521391771733761*${_u_distance}
variable latticeconst_converted equal 3.521391771733761*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139177173376
Lattice spacing in x,y,z = 3.5213918 3.5213918 3.5213918
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213918 35.213918 35.213918)
  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.213918 35.213918 35.213918)
  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_ChoiKimSeol_2017_NiMn__MO_348689608050_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.9622831874    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9622831874/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9622831874/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9622831874/(1*1*${_u_distance})
variable      V0_metal equal 43665.9622831874/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9622831874*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9622831874 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 313.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "313.15 - 0.2"
variable      T_up  equal  "313.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_348689608050_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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17638.129     -17638.129     -17800         -17800          313.15         313.15         43665.962      43665.962      3959.517       3959.517     
      1000  -17465.43      -17465.43      -17636.025     -17636.025      330.02728      330.02728      44129.051      44129.051      1692.4922      1692.4922    
Loop time of 50.8912 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.698 ns/day, 14.136 hours/ns, 19.650 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    | 50.741     | 50.741     | 50.741     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021415   | 0.021415   | 0.021415   |   0.0 |  0.04
Output  | 0.00014491 | 0.00014491 | 0.00014491 |   0.0 |  0.00
Modify  | 0.11825    | 0.11825    | 0.11825    |   0.0 |  0.23
Other   |            | 0.01069    |            |       |  0.02

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17465.43      -17465.43      -17636.025     -17636.025      330.02728      330.02728      44129.051      44129.051      1692.4922      1692.4922    
      2000  -17475.395     -17475.395     -17634.356     -17634.356      307.51999      307.51999      44152.457      44152.457      686.24277      686.24277    
Loop time of 57.8551 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.071 hours/ns, 17.285 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    | 57.706     | 57.706     | 57.706     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021502   | 0.021502   | 0.021502   |   0.0 |  0.04
Output  | 5.1738e-05 | 5.1738e-05 | 5.1738e-05 |   0.0 |  0.00
Modify  | 0.11712    | 0.11712    | 0.11712    |   0.0 |  0.20
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 314186
Ave neighs/atom = 78.5465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17475.395     -17475.395     -17634.356     -17634.356      307.51999      307.51999      44152.457      44152.457      686.24277      686.24277    
      3000  -17474.878     -17474.878     -17633.746     -17633.746      307.34121      307.34121      44163.112      44163.112      244.46334      244.46334    
Loop time of 57.9328 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.092 hours/ns, 17.261 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    | 57.784     | 57.784     | 57.784     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021439   | 0.021439   | 0.021439   |   0.0 |  0.04
Output  | 7.2236e-05 | 7.2236e-05 | 7.2236e-05 |   0.0 |  0.00
Modify  | 0.11705    | 0.11705    | 0.11705    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 314200
Ave neighs/atom = 78.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17474.878     -17474.878     -17633.746     -17633.746      307.34121      307.34121      44163.112      44163.112      244.46334      244.46334    
      4000  -17471.766     -17471.766     -17634.986     -17634.986      315.76117      315.76117      44171.489      44171.489     -64.328888     -64.328888    
Loop time of 57.9916 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.109 hours/ns, 17.244 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    | 57.843     | 57.843     | 57.843     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.04
Output  | 7.4691e-05 | 7.4691e-05 | 7.4691e-05 |   0.0 |  0.00
Modify  | 0.11691    | 0.11691    | 0.11691    |   0.0 |  0.20
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 314256
Ave neighs/atom = 78.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17471.766     -17471.766     -17634.986     -17634.986      315.76117      315.76117      44171.489      44171.489     -64.328888     -64.328888    
      5000  -17476.646     -17476.646     -17635.938     -17635.938      308.16058      308.16058      44171.708      44171.708     -252.92702     -252.92702    
Loop time of 57.8551 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.071 hours/ns, 17.285 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    | 57.706     | 57.706     | 57.706     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021435   | 0.021435   | 0.021435   |   0.0 |  0.04
Output  | 3.9174e-05 | 3.9174e-05 | 3.9174e-05 |   0.0 |  0.00
Modify  | 0.11733    | 0.11733    | 0.11733    |   0.0 |  0.20
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314028
Ave neighs/atom = 78.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.237775000974, Press = -329.083930510003
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17476.646     -17476.646     -17635.938     -17635.938      308.16058      308.16058      44171.708      44171.708     -252.92702     -252.92702    
      6000  -17470.732     -17470.732     -17633.121     -17633.121      314.15273      314.15273      44206.033      44206.033     -1336.9633     -1336.9633    
Loop time of 58.0925 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.137 hours/ns, 17.214 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.94      | 57.94      | 57.94      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021494   | 0.021494   | 0.021494   |   0.0 |  0.04
Output  | 3.9575e-05 | 3.9575e-05 | 3.9575e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314168
Ave neighs/atom = 78.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.719651888724, Press = -43.7269380116171
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17470.732     -17470.732     -17633.121     -17633.121      314.15273      314.15273      44206.033      44206.033     -1336.9633     -1336.9633    
      7000  -17476.47      -17476.47      -17637.072     -17637.072      310.69572      310.69572      44235.966      44235.966     -3006.0903     -3006.0903    
Loop time of 58.1051 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.140 hours/ns, 17.210 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    | 57.952     | 57.952     | 57.952     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021619   | 0.021619   | 0.021619   |   0.0 |  0.04
Output  | 4.0246e-05 | 4.0246e-05 | 4.0246e-05 |   0.0 |  0.00
Modify  | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 314094
Ave neighs/atom = 78.5235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.980621360617, Press = -16.994643497355
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17476.47      -17476.47      -17637.072     -17637.072      310.69572      310.69572      44235.966      44235.966     -3006.0903     -3006.0903    
      8000  -17473.415     -17473.415     -17636.107     -17636.107      314.7378       314.7378       44222.672      44222.672     -2310.4707     -2310.4707    
Loop time of 58.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.136 hours/ns, 17.215 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.938     | 57.938     | 57.938     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021582   | 0.021582   | 0.021582   |   0.0 |  0.04
Output  | 3.9034e-05 | 3.9034e-05 | 3.9034e-05 |   0.0 |  0.00
Modify  | 0.12061    | 0.12061    | 0.12061    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 313914
Ave neighs/atom = 78.4785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.909717789854, Press = 1.77650901516793
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17473.415     -17473.415     -17636.107     -17636.107      314.7378       314.7378       44222.672      44222.672     -2310.4707     -2310.4707    
      9000  -17477.288     -17477.288     -17638.439     -17638.439      311.75657      311.75657      44179.74       44179.74      -813.34266     -813.34266    
Loop time of 58.1512 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.153 hours/ns, 17.197 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    | 57.999     | 57.999     | 57.999     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021465   | 0.021465   | 0.021465   |   0.0 |  0.04
Output  | 5.2169e-05 | 5.2169e-05 | 5.2169e-05 |   0.0 |  0.00
Modify  | 0.12069    | 0.12069    | 0.12069    |   0.0 |  0.21
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 313888
Ave neighs/atom = 78.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.666835745757, Press = 3.30890491184289
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17477.288     -17477.288     -17638.439     -17638.439      311.75657      311.75657      44179.74       44179.74      -813.34266     -813.34266    
     10000  -17472.137     -17472.137     -17634.699     -17634.699      314.4876       314.4876       44169.605      44169.605     -38.366646     -38.366646    
Loop time of 58.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.489 ns/day, 16.117 hours/ns, 17.235 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    | 57.869     | 57.869     | 57.869     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021445   | 0.021445   | 0.021445   |   0.0 |  0.04
Output  | 3.9254e-05 | 3.9254e-05 | 3.9254e-05 |   0.0 |  0.00
Modify  | 0.12053    | 0.12053    | 0.12053    |   0.0 |  0.21
Other   |            | 0.0103     |            |       |  0.02

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

Total # of neighbors = 314002
Ave neighs/atom = 78.5005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.731128847862, Press = 4.51308357337395
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17472.137     -17472.137     -17634.699     -17634.699      314.4876       314.4876       44169.605      44169.605     -38.366646     -38.366646    
     11000  -17474.547     -17474.547     -17634.707     -17634.707      309.84095      309.84095      44142.976      44142.976      977.02148      977.02148    
Loop time of 58.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.161 hours/ns, 17.188 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    | 58.027     | 58.027     | 58.027     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021518   | 0.021518   | 0.021518   |   0.0 |  0.04
Output  | 3.677e-05  | 3.677e-05  | 3.677e-05  |   0.0 |  0.00
Modify  | 0.12063    | 0.12063    | 0.12063    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 314038
Ave neighs/atom = 78.5095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.93959431008, Press = 3.02372943150653
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17474.547     -17474.547     -17634.707     -17634.707      309.84095      309.84095      44142.976      44142.976      977.02148      977.02148    
     12000  -17468.022     -17468.022     -17636.678     -17636.678      326.27625      326.27625      44119.592      44119.592      2036.5475      2036.5475    
Loop time of 58.2106 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.170 hours/ns, 17.179 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    | 58.058     | 58.058     | 58.058     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021424   | 0.021424   | 0.021424   |   0.0 |  0.04
Output  | 3.8613e-05 | 3.8613e-05 | 3.8613e-05 |   0.0 |  0.00
Modify  | 0.1206     | 0.1206     | 0.1206     |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 314216
Ave neighs/atom = 78.554
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.088062840295, Press = 5.44457265342179
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17468.022     -17468.022     -17636.678     -17636.678      326.27625      326.27625      44119.592      44119.592      2036.5475      2036.5475    
     13000  -17476.45      -17476.45      -17636.809     -17636.809      310.22611      310.22611      44066.125      44066.125      4053.9851      4053.9851    
Loop time of 58.0806 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.133 hours/ns, 17.217 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    | 57.928     | 57.928     | 57.928     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021404   | 0.021404   | 0.021404   |   0.0 |  0.04
Output  | 4.269e-05  | 4.269e-05  | 4.269e-05  |   0.0 |  0.00
Modify  | 0.12061    | 0.12061    | 0.12061    |   0.0 |  0.21
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314230
Ave neighs/atom = 78.5575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.171725936432, Press = 0.937914277463159
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17476.45      -17476.45      -17636.809     -17636.809      310.22611      310.22611      44066.125      44066.125      4053.9851      4053.9851    
     14000  -17471.243     -17471.243     -17633.47      -17633.47       313.83976      313.83976      44135.19       44135.19       1633.1208      1633.1208    
Loop time of 58.145 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.151 hours/ns, 17.198 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    | 57.992     | 57.992     | 57.992     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021464   | 0.021464   | 0.021464   |   0.0 |  0.04
Output  | 8.8377e-05 | 8.8377e-05 | 8.8377e-05 |   0.0 |  0.00
Modify  | 0.12061    | 0.12061    | 0.12061    |   0.0 |  0.21
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 314280
Ave neighs/atom = 78.57
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.304746361642, Press = -1.91015571335047
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17471.243     -17471.243     -17633.47      -17633.47       313.83976      313.83976      44135.19       44135.19       1633.1208      1633.1208    
     15000  -17476.904     -17476.904     -17636.926     -17636.926      309.57375      309.57375      44138.245      44138.245      1037.7728      1037.7728    
Loop time of 58.1476 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.152 hours/ns, 17.198 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    | 57.995     | 57.995     | 57.995     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021462   | 0.021462   | 0.021462   |   0.0 |  0.04
Output  | 3.7681e-05 | 3.7681e-05 | 3.7681e-05 |   0.0 |  0.00
Modify  | 0.12056    | 0.12056    | 0.12056    |   0.0 |  0.21
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 314162
Ave neighs/atom = 78.5405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.406599256924, Press = -1.89367441195494
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17476.904     -17476.904     -17636.926     -17636.926      309.57375      309.57375      44138.245      44138.245      1037.7728      1037.7728    
     16000  -17472.127     -17472.127     -17636.055     -17636.055      317.1286       317.1286       44156.97       44156.97       504.97248      504.97248    
Loop time of 58.3208 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.200 hours/ns, 17.147 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    | 58.168     | 58.168     | 58.168     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021597   | 0.021597   | 0.021597   |   0.0 |  0.04
Output  | 3.8653e-05 | 3.8653e-05 | 3.8653e-05 |   0.0 |  0.00
Modify  | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 314132
Ave neighs/atom = 78.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.353047452543, Press = -3.54493153259143
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17472.127     -17472.127     -17636.055     -17636.055      317.1286       317.1286       44156.97       44156.97       504.97248      504.97248    
     17000  -17476.069     -17476.069     -17635.521     -17635.521      308.46991      308.46991      44182.47       44182.47      -711.46401     -711.46401    
Loop time of 58.2569 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.483 ns/day, 16.182 hours/ns, 17.165 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    | 58.104     | 58.104     | 58.104     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021607   | 0.021607   | 0.021607   |   0.0 |  0.04
Output  | 4.1268e-05 | 4.1268e-05 | 4.1268e-05 |   0.0 |  0.00
Modify  | 0.12054    | 0.12054    | 0.12054    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314008
Ave neighs/atom = 78.502
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.37480276345, Press = -6.35260793421603
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17476.069     -17476.069     -17635.521     -17635.521      308.46991      308.46991      44182.47       44182.47      -711.46401     -711.46401    
     18000  -17469.629     -17469.629     -17633.004     -17633.004      316.05967      316.05967      44242.481      44242.481     -2788.2761     -2788.2761    
Loop time of 58.2755 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.483 ns/day, 16.188 hours/ns, 17.160 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    | 58.123     | 58.123     | 58.123     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021456   | 0.021456   | 0.021456   |   0.0 |  0.04
Output  | 3.6238e-05 | 3.6238e-05 | 3.6238e-05 |   0.0 |  0.00
Modify  | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 314112
Ave neighs/atom = 78.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.36491919256, Press = -5.66236004533897
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17469.629     -17469.629     -17633.004     -17633.004      316.05967      316.05967      44242.481      44242.481     -2788.2761     -2788.2761    
     19000  -17474.268     -17474.268     -17633.753     -17633.753      308.53345      308.53345      44219.691      44219.691     -2090.5285     -2090.5285    
Loop time of 58.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.167 hours/ns, 17.182 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    | 58.049     | 58.049     | 58.049     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021521   | 0.021521   | 0.021521   |   0.0 |  0.04
Output  | 2.9466e-05 | 2.9466e-05 | 2.9466e-05 |   0.0 |  0.00
Modify  | 0.12057    | 0.12057    | 0.12057    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 313992
Ave neighs/atom = 78.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.491593336651, Press = -1.2743595388289
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17474.268     -17474.268     -17633.753     -17633.753      308.53345      308.53345      44219.691      44219.691     -2090.5285     -2090.5285    
     20000  -17470.403     -17470.403     -17633.347     -17633.347      315.22481      315.22481      44211.746      44211.746     -1605.1691     -1605.1691    
Loop time of 58.2379 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.177 hours/ns, 17.171 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    | 58.085     | 58.085     | 58.085     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021502   | 0.021502   | 0.021502   |   0.0 |  0.04
Output  | 4.1458e-05 | 4.1458e-05 | 4.1458e-05 |   0.0 |  0.00
Modify  | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 314080
Ave neighs/atom = 78.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462750455052, Press = 0.133818175928309
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17470.403     -17470.403     -17633.347     -17633.347      315.22481      315.22481      44211.746      44211.746     -1605.1691     -1605.1691    
     21000  -17475.53      -17475.53      -17635.741     -17635.741      309.93903      309.93903      44189.808      44189.808     -1037.0682     -1037.0682    
Loop time of 58.0583 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.127 hours/ns, 17.224 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    | 57.906     | 57.906     | 57.906     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021376   | 0.021376   | 0.021376   |   0.0 |  0.04
Output  | 4.245e-05  | 4.245e-05  | 4.245e-05  |   0.0 |  0.00
Modify  | 0.12056    | 0.12056    | 0.12056    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 313990
Ave neighs/atom = 78.4975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.389761388003, Press = 1.75622411787904
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17475.53      -17475.53      -17635.741     -17635.741      309.93903      309.93903      44189.808      44189.808     -1037.0682     -1037.0682    
     22000  -17471.321     -17471.321     -17635.278     -17635.278      317.18687      317.18687      44176.352      44176.352     -354.61686     -354.61686    
Loop time of 58.2383 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.177 hours/ns, 17.171 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    | 58.086     | 58.086     | 58.086     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021365   | 0.021365   | 0.021365   |   0.0 |  0.04
Output  | 3.7721e-05 | 3.7721e-05 | 3.7721e-05 |   0.0 |  0.00
Modify  | 0.12046    | 0.12046    | 0.12046    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314080
Ave neighs/atom = 78.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.295475084237, Press = 1.5222457921265
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17471.321     -17471.321     -17635.278     -17635.278      317.18687      317.18687      44176.352      44176.352     -354.61686     -354.61686    
     23000  -17475.829     -17475.829     -17638.411     -17638.411      314.52701      314.52701      44145.56       44145.56       651.88355      651.88355    
Loop time of 58.2319 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.176 hours/ns, 17.173 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    | 58.08      | 58.08      | 58.08      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021324   | 0.021324   | 0.021324   |   0.0 |  0.04
Output  | 4.8632e-05 | 4.8632e-05 | 4.8632e-05 |   0.0 |  0.00
Modify  | 0.12052    | 0.12052    | 0.12052    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314062
Ave neighs/atom = 78.5155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.224626813746, Press = 2.48698655639163
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17475.829     -17475.829     -17638.411     -17638.411      314.52701      314.52701      44145.56       44145.56       651.88355      651.88355    
     24000  -17470.768     -17470.768     -17635.717     -17635.717      319.10524      319.10524      44110.651      44110.651      2320.4834      2320.4834    
Loop time of 58.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.144 hours/ns, 17.206 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    | 57.968     | 57.968     | 57.968     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021268   | 0.021268   | 0.021268   |   0.0 |  0.04
Output  | 4.196e-05  | 4.196e-05  | 4.196e-05  |   0.0 |  0.00
Modify  | 0.12056    | 0.12056    | 0.12056    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 314022
Ave neighs/atom = 78.5055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.286753638939, Press = 2.88949523717763
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17470.768     -17470.768     -17635.717     -17635.717      319.10524      319.10524      44110.651      44110.651      2320.4834      2320.4834    
     25000  -17476.801     -17476.801     -17641.026     -17641.026      317.70588      317.70588      44104.572      44104.572      2153.3742      2153.3742    
Loop time of 58.2874 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.191 hours/ns, 17.156 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    | 58.135     | 58.135     | 58.135     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021269   | 0.021269   | 0.021269   |   0.0 |  0.04
Output  | 3.709e-05  | 3.709e-05  | 3.709e-05  |   0.0 |  0.00
Modify  | 0.12052    | 0.12052    | 0.12052    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 314198
Ave neighs/atom = 78.5495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.325177203858, Press = 0.448526314534168
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17476.801     -17476.801     -17641.026     -17641.026      317.70588      317.70588      44104.572      44104.572      2153.3742      2153.3742    
     26000  -17469.255     -17469.255     -17633.808     -17633.808      318.33869      318.33869      44135.47       44135.47       1601.9124      1601.9124    
Loop time of 58.3239 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.201 hours/ns, 17.146 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    | 58.172     | 58.172     | 58.172     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021264   | 0.021264   | 0.021264   |   0.0 |  0.04
Output  | 3.9124e-05 | 3.9124e-05 | 3.9124e-05 |   0.0 |  0.00
Modify  | 0.12047    | 0.12047    | 0.12047    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314046
Ave neighs/atom = 78.5115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.330296116036, Press = -0.558585205700696
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17469.255     -17469.255     -17633.808     -17633.808      318.33869      318.33869      44135.47       44135.47       1601.9124      1601.9124    
     27000  -17473.902     -17473.902     -17636.341     -17636.341      314.248        314.248        44142.18       44142.18       1002.901       1002.901     
Loop time of 58.3688 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.480 ns/day, 16.214 hours/ns, 17.132 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    | 58.217     | 58.217     | 58.217     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021279   | 0.021279   | 0.021279   |   0.0 |  0.04
Output  | 3.696e-05  | 3.696e-05  | 3.696e-05  |   0.0 |  0.00
Modify  | 0.12054    | 0.12054    | 0.12054    |   0.0 |  0.21
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 314152
Ave neighs/atom = 78.538
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.353514786072, Press = -1.65357014768437
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17473.902     -17473.902     -17636.341     -17636.341      314.248        314.248        44142.18       44142.18       1002.901       1002.901     
     28000  -17476.12      -17476.12      -17639.015     -17639.015      315.13003      315.13003      44163.535      44163.535     -153.83318     -153.83318    
Loop time of 58.1826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.162 hours/ns, 17.187 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    | 58.031     | 58.031     | 58.031     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021311   | 0.021311   | 0.021311   |   0.0 |  0.04
Output  | 3.7501e-05 | 3.7501e-05 | 3.7501e-05 |   0.0 |  0.00
Modify  | 0.12043    | 0.12043    | 0.12043    |   0.0 |  0.21
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314132
Ave neighs/atom = 78.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.344832447576, Press = -2.17617423602162
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17476.12      -17476.12      -17639.015     -17639.015      315.13003      315.13003      44163.535      44163.535     -153.83318     -153.83318    
     29000  -17471.982     -17471.982     -17635.831     -17635.831      316.97852      316.97852      44185.785      44185.785     -801.88462     -801.88462    
Loop time of 58.3228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.201 hours/ns, 17.146 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    | 58.171     | 58.171     | 58.171     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021168   | 0.021168   | 0.021168   |   0.0 |  0.04
Output  | 3.8483e-05 | 3.8483e-05 | 3.8483e-05 |   0.0 |  0.00
Modify  | 0.12039    | 0.12039    | 0.12039    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314014
Ave neighs/atom = 78.5035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.423910799741, Press = -2.49624958024038
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17471.982     -17471.982     -17635.831     -17635.831      316.97852      316.97852      44185.785      44185.785     -801.88462     -801.88462    
     30000  -17473.824     -17473.824     -17635.257     -17635.257      312.30314      312.30314      44214.056      44214.056     -1961.8056     -1961.8056    
Loop time of 58.3322 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.203 hours/ns, 17.143 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    | 58.18      | 58.18      | 58.18      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021349   | 0.021349   | 0.021349   |   0.0 |  0.04
Output  | 3.6078e-05 | 3.6078e-05 | 3.6078e-05 |   0.0 |  0.00
Modify  | 0.1205     | 0.1205     | 0.1205     |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314066
Ave neighs/atom = 78.5165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.418927426369, Press = -2.53629111527035
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17473.824     -17473.824     -17635.257     -17635.257      312.30314      312.30314      44214.056      44214.056     -1961.8056     -1961.8056    
     31000  -17474.05      -17474.05      -17636.39      -17636.39       314.05752      314.05752      44263.112      44263.112     -4046.6575     -4046.6575    
Loop time of 58.3494 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.208 hours/ns, 17.138 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    | 58.197     | 58.197     | 58.197     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021219   | 0.021219   | 0.021219   |   0.0 |  0.04
Output  | 4.4164e-05 | 4.4164e-05 | 4.4164e-05 |   0.0 |  0.00
Modify  | 0.12052    | 0.12052    | 0.12052    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314046
Ave neighs/atom = 78.5115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.449464188151, Press = -1.54819421518507
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17474.05      -17474.05      -17636.39      -17636.39       314.05752      314.05752      44263.112      44263.112     -4046.6575     -4046.6575    
     32000  -17467.831     -17467.831     -17630.043     -17630.043      313.80957      313.80957      44212.5        44212.5       -1371.068      -1371.068     
Loop time of 58.2171 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.171 hours/ns, 17.177 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    | 58.065     | 58.065     | 58.065     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021249   | 0.021249   | 0.021249   |   0.0 |  0.04
Output  | 4.7109e-05 | 4.7109e-05 | 4.7109e-05 |   0.0 |  0.00
Modify  | 0.1205     | 0.1205     | 0.1205     |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 313764
Ave neighs/atom = 78.441
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.482669905522, Press = 0.401915865298552
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17467.831     -17467.831     -17630.043     -17630.043      313.80957      313.80957      44212.5        44212.5       -1371.068      -1371.068     
     33000  -17477.338     -17477.338     -17637.508     -17637.508      309.86013      309.86013      44185.665      44185.665     -998.13627     -998.13627    
Loop time of 58.1992 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.166 hours/ns, 17.182 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    | 58.047     | 58.047     | 58.047     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021211   | 0.021211   | 0.021211   |   0.0 |  0.04
Output  | 4.4874e-05 | 4.4874e-05 | 4.4874e-05 |   0.0 |  0.00
Modify  | 0.12044    | 0.12044    | 0.12044    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314154
Ave neighs/atom = 78.5385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.514596657412, Press = 0.923405881440349
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17477.338     -17477.338     -17637.508     -17637.508      309.86013      309.86013      44185.665      44185.665     -998.13627     -998.13627    
     34000  -17472.436     -17472.436     -17635.873     -17635.873      316.18046      316.18046      44179.967      44179.967     -545.04791     -545.04791    
Loop time of 58.1691 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.158 hours/ns, 17.191 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    | 58.017     | 58.017     | 58.017     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021315   | 0.021315   | 0.021315   |   0.0 |  0.04
Output  | 6.3069e-05 | 6.3069e-05 | 6.3069e-05 |   0.0 |  0.00
Modify  | 0.12055    | 0.12055    | 0.12055    |   0.0 |  0.21
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314040
Ave neighs/atom = 78.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.501871882307, Press = 1.4360750630328
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17472.436     -17472.436     -17635.873     -17635.873      316.18046      316.18046      44179.967      44179.967     -545.04791     -545.04791    
     35000  -17474.022     -17474.022     -17634.939     -17634.939      311.30608      311.30608      44158.525      44158.525      405.04897      405.04897    
Loop time of 58.3069 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.196 hours/ns, 17.151 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    | 58.155     | 58.155     | 58.155     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021347   | 0.021347   | 0.021347   |   0.0 |  0.04
Output  | 4.756e-05  | 4.756e-05  | 4.756e-05  |   0.0 |  0.00
Modify  | 0.12036    | 0.12036    | 0.12036    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314098
Ave neighs/atom = 78.5245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.509711116221, Press = 2.17702825043235
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17474.022     -17474.022     -17634.939     -17634.939      311.30608      311.30608      44158.525      44158.525      405.04897      405.04897    
     36000  -17476.703     -17476.703     -17637.962     -17637.962      311.96765      311.96765      44111.88       44111.88       1974.8234      1974.8234    
Loop time of 58.3065 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.196 hours/ns, 17.151 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    | 58.154     | 58.154     | 58.154     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021281   | 0.021281   | 0.021281   |   0.0 |  0.04
Output  | 4.5917e-05 | 4.5917e-05 | 4.5917e-05 |   0.0 |  0.00
Modify  | 0.12049    | 0.12049    | 0.12049    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314168
Ave neighs/atom = 78.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50001292863, Press = 2.89533361453638
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17476.703     -17476.703     -17637.962     -17637.962      311.96765      311.96765      44111.88       44111.88       1974.8234      1974.8234    
     37000  -17473.09      -17473.09      -17633.835     -17633.835      310.97247      310.97247      44123.982      44123.982      1954.565       1954.565     
Loop time of 58.1464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.152 hours/ns, 17.198 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    | 57.994     | 57.994     | 57.994     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021235   | 0.021235   | 0.021235   |   0.0 |  0.04
Output  | 4.4635e-05 | 4.4635e-05 | 4.4635e-05 |   0.0 |  0.00
Modify  | 0.12046    | 0.12046    | 0.12046    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314246
Ave neighs/atom = 78.5615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.488775747644, Press = 0.872838260659722
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17473.09      -17473.09      -17633.835     -17633.835      310.97247      310.97247      44123.982      44123.982      1954.565       1954.565     
     38000  -17473.607     -17473.607     -17633.744     -17633.744      309.79533      309.79533      44129.406      44129.406      1705.7094      1705.7094    
Loop time of 58.3505 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.208 hours/ns, 17.138 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    | 58.199     | 58.199     | 58.199     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021281   | 0.021281   | 0.021281   |   0.0 |  0.04
Output  | 4.5907e-05 | 4.5907e-05 | 4.5907e-05 |   0.0 |  0.00
Modify  | 0.12043    | 0.12043    | 0.12043    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314258
Ave neighs/atom = 78.5645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.489555377698, Press = -0.0372947263009293
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17473.607     -17473.607     -17633.744     -17633.744      309.79533      309.79533      44129.406      44129.406      1705.7094      1705.7094    
     39000  -17476.182     -17476.182     -17635.431     -17635.431      308.0779       308.0779       44141.805      44141.805      1057.084       1057.084     
Loop time of 58.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.478 ns/day, 16.234 hours/ns, 17.111 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    | 58.291     | 58.291     | 58.291     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021363   | 0.021363   | 0.021363   |   0.0 |  0.04
Output  | 4.5616e-05 | 4.5616e-05 | 4.5616e-05 |   0.0 |  0.00
Modify  | 0.12044    | 0.12044    | 0.12044    |   0.0 |  0.21
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 314196
Ave neighs/atom = 78.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.451037560437, Press = -0.514034813691467
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17476.182     -17476.182     -17635.431     -17635.431      308.0779       308.0779       44141.805      44141.805      1057.084       1057.084     
     40000  -17477.075     -17477.075     -17637.888     -17637.888      311.10335      311.10335      44147.498      44147.498      473.47099      473.47099    
Loop time of 58.3011 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.195 hours/ns, 17.152 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    | 58.149     | 58.149     | 58.149     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021309   | 0.021309   | 0.021309   |   0.0 |  0.04
Output  | 5.0255e-05 | 5.0255e-05 | 5.0255e-05 |   0.0 |  0.00
Modify  | 0.12046    | 0.12046    | 0.12046    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314064
Ave neighs/atom = 78.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.448979526518, Press = -0.635188295210604
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17477.075     -17477.075     -17637.888     -17637.888      311.10335      311.10335      44147.498      44147.498      473.47099      473.47099    
     41000  -17469.892     -17469.892     -17630.716     -17630.716      311.12504      311.12504      44150.113      44150.113      1163.2493      1163.2493    
Loop time of 58.3837 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.480 ns/day, 16.218 hours/ns, 17.128 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    | 58.232     | 58.232     | 58.232     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02124    | 0.02124    | 0.02124    |   0.0 |  0.04
Output  | 4.5816e-05 | 4.5816e-05 | 4.5816e-05 |   0.0 |  0.00
Modify  | 0.12047    | 0.12047    | 0.12047    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314106
Ave neighs/atom = 78.5265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.474655795883, Press = -1.92500732382575
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17469.892     -17469.892     -17630.716     -17630.716      311.12504      311.12504      44150.113      44150.113      1163.2493      1163.2493    
     42000  -17476.043     -17476.043     -17637.629     -17637.629      312.59902      312.59902      44178.566      44178.566     -669.52383     -669.52383    
Loop time of 58.4501 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.478 ns/day, 16.236 hours/ns, 17.109 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    | 58.298     | 58.298     | 58.298     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021316   | 0.021316   | 0.021316   |   0.0 |  0.04
Output  | 4.4574e-05 | 4.4574e-05 | 4.4574e-05 |   0.0 |  0.00
Modify  | 0.12057    | 0.12057    | 0.12057    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314186
Ave neighs/atom = 78.5465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.500522693019, Press = -1.90778755568176
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17476.043     -17476.043     -17637.629     -17637.629      312.59902      312.59902      44178.566      44178.566     -669.52383     -669.52383    
     43000  -17471.7       -17471.7       -17634.639     -17634.639      315.21752      315.21752      44197.544      44197.544     -1144.4975     -1144.4975    
Loop time of 58.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.478 ns/day, 16.234 hours/ns, 17.111 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    | 58.289     | 58.289     | 58.289     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021229   | 0.021229   | 0.021229   |   0.0 |  0.04
Output  | 4.9604e-05 | 4.9604e-05 | 4.9604e-05 |   0.0 |  0.00
Modify  | 0.12051    | 0.12051    | 0.12051    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 313954
Ave neighs/atom = 78.4885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.488241097589, Press = -0.994772695875531
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17471.7       -17471.7       -17634.639     -17634.639      315.21752      315.21752      44197.544      44197.544     -1144.4975     -1144.4975    
     44000  -17475.571     -17475.571     -17634.265     -17634.265      307.00454      307.00454      44193.352      44193.352     -1050.728      -1050.728     
Loop time of 58.4202 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.479 ns/day, 16.228 hours/ns, 17.117 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    | 58.268     | 58.268     | 58.268     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021285   | 0.021285   | 0.021285   |   0.0 |  0.04
Output  | 5.0375e-05 | 5.0375e-05 | 5.0375e-05 |   0.0 |  0.00
Modify  | 0.1205     | 0.1205     | 0.1205     |   0.0 |  0.21
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314098
Ave neighs/atom = 78.5245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428602711758, Press = -0.449293177188359
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17475.571     -17475.571     -17634.265     -17634.265      307.00454      307.00454      44193.352      44193.352     -1050.728      -1050.728     
     45000  -17475.55      -17475.55      -17635.793     -17635.793      310.00126      310.00126      44198.357      44198.357     -1413.7817     -1413.7817    
Loop time of 58.4579 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.478 ns/day, 16.238 hours/ns, 17.106 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    | 58.306     | 58.306     | 58.306     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 4.4975e-05 | 4.4975e-05 | 4.4975e-05 |   0.0 |  0.00
Modify  | 0.12047    | 0.12047    | 0.12047    |   0.0 |  0.21
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 314080
Ave neighs/atom = 78.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.421956987007, Press = -0.141451942574069
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17475.55      -17475.55      -17635.793     -17635.793      310.00126      310.00126      44198.357      44198.357     -1413.7817     -1413.7817    
     46000  -17470.354     -17470.354     -17633.351     -17633.351      315.32826      315.32826      44198.756      44198.756     -1049.1354     -1049.1354    
Loop time of 58.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.480 ns/day, 16.213 hours/ns, 17.134 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    | 58.213     | 58.213     | 58.213     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 3.9093e-05 | 3.9093e-05 | 3.9093e-05 |   0.0 |  0.00
Modify  | 0.12047    | 0.12047    | 0.12047    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314100
Ave neighs/atom = 78.525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.373481879245, Press = 0.450912587189022
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17470.354     -17470.354     -17633.351     -17633.351      315.32826      315.32826      44198.756      44198.756     -1049.1354     -1049.1354    
     47000  -17474.488     -17474.488     -17636.218     -17636.218      312.87716      312.87716      44185.785      44185.785     -893.24907     -893.24907    
Loop time of 58.3884 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.480 ns/day, 16.219 hours/ns, 17.127 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    | 58.236     | 58.236     | 58.236     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021251   | 0.021251   | 0.021251   |   0.0 |  0.04
Output  | 4.3342e-05 | 4.3342e-05 | 4.3342e-05 |   0.0 |  0.00
Modify  | 0.12045    | 0.12045    | 0.12045    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314014
Ave neighs/atom = 78.5035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.385438735125, Press = 1.29646898714922
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17474.488     -17474.488     -17636.218     -17636.218      312.87716      312.87716      44185.785      44185.785     -893.24907     -893.24907    
     48000  -17469.922     -17469.922     -17633.851     -17633.851      317.13167      317.13167      44168.984      44168.984      142.3627       142.3627     
Loop time of 58.3892 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.480 ns/day, 16.219 hours/ns, 17.126 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    | 58.237     | 58.237     | 58.237     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021259   | 0.021259   | 0.021259   |   0.0 |  0.04
Output  | 4.3512e-05 | 4.3512e-05 | 4.3512e-05 |   0.0 |  0.00
Modify  | 0.12039    | 0.12039    | 0.12039    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314060
Ave neighs/atom = 78.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.417765153971, Press = 2.01241067073402
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17469.922     -17469.922     -17633.851     -17633.851      317.13167      317.13167      44168.984      44168.984      142.3627       142.3627     
     49000  -17474.174     -17474.174     -17633.828     -17633.828      308.86013      308.86013      44141.001      44141.001      1178.7803      1178.7803    
Loop time of 58.3356 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.204 hours/ns, 17.142 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    | 58.183     | 58.183     | 58.183     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021429   | 0.021429   | 0.021429   |   0.0 |  0.04
Output  | 4.2681e-05 | 4.2681e-05 | 4.2681e-05 |   0.0 |  0.00
Modify  | 0.12039    | 0.12039    | 0.12039    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314046
Ave neighs/atom = 78.5115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.408917766362, Press = 1.21621103937792
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17474.174     -17474.174     -17633.828     -17633.828      308.86013      308.86013      44141.001      44141.001      1178.7803      1178.7803    
     50000  -17474.028     -17474.028     -17635.262     -17635.262      311.91944      311.91944      44141.252      44141.252      1111.1881      1111.1881    
Loop time of 58.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.479 ns/day, 16.231 hours/ns, 17.115 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    | 58.278     | 58.278     | 58.278     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02125    | 0.02125    | 0.02125    |   0.0 |  0.04
Output  | 3.5337e-05 | 3.5337e-05 | 3.5337e-05 |   0.0 |  0.00
Modify  | 0.12039    | 0.12039    | 0.12039    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314134
Ave neighs/atom = 78.5335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.388028266414, Press = 0.561083187836848
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17474.028     -17474.028     -17635.262     -17635.262      311.91944      311.91944      44141.252      44141.252      1111.1881      1111.1881    
     51000  -17473.819     -17473.819     -17633.248     -17633.248      308.42681      308.42681      44148.045      44148.045      989.16952      989.16952    
Loop time of 58.3117 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.198 hours/ns, 17.149 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    | 58.16      | 58.16      | 58.16      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02124    | 0.02124    | 0.02124    |   0.0 |  0.04
Output  | 3.3854e-05 | 3.3854e-05 | 3.3854e-05 |   0.0 |  0.00
Modify  | 0.12035    | 0.12035    | 0.12035    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314100
Ave neighs/atom = 78.525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.404990657548, Press = 0.11898465412609
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17473.819     -17473.819     -17633.248     -17633.248      308.42681      308.42681      44148.045      44148.045      989.16952      989.16952    
     52000  -17467.867     -17467.867     -17633.054     -17633.054      319.56642      319.56642      44154.987      44154.987      831.09278      831.09278    
Loop time of 58.2914 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.192 hours/ns, 17.155 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    | 58.14      | 58.14      | 58.14      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021231   | 0.021231   | 0.021231   |   0.0 |  0.04
Output  | 3.2972e-05 | 3.2972e-05 | 3.2972e-05 |   0.0 |  0.00
Modify  | 0.12038    | 0.12038    | 0.12038    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314166
Ave neighs/atom = 78.5415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.42314786929, Press = 0.0132782172192679
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17467.867     -17467.867     -17633.054     -17633.054      319.56642      319.56642      44154.987      44154.987      831.09278      831.09278    
     53000  -17476.348     -17476.348     -17639.591     -17639.591      315.80534      315.80534      44135.191      44135.191      943.60558      943.60558    
Loop time of 58.2217 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.484 ns/day, 16.173 hours/ns, 17.176 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    | 58.07      | 58.07      | 58.07      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021166   | 0.021166   | 0.021166   |   0.0 |  0.04
Output  | 4.4794e-05 | 4.4794e-05 | 4.4794e-05 |   0.0 |  0.00
Modify  | 0.12038    | 0.12038    | 0.12038    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 314158
Ave neighs/atom = 78.5395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.447188149041, Press = -0.364947136625032
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17476.348     -17476.348     -17639.591     -17639.591      315.80534      315.80534      44135.191      44135.191      943.60558      943.60558    
     54000  -17477.344     -17477.344     -17637.242     -17637.242      309.3349       309.3349       44128.375      44128.375      1287.5303      1287.5303    
Loop time of 58.3176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.199 hours/ns, 17.147 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    | 58.166     | 58.166     | 58.166     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021183   | 0.021183   | 0.021183   |   0.0 |  0.04
Output  | 4.6819e-05 | 4.6819e-05 | 4.6819e-05 |   0.0 |  0.00
Modify  | 0.12039    | 0.12039    | 0.12039    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314058
Ave neighs/atom = 78.5145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.450583931128, Press = -1.03354826888619
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17477.344     -17477.344     -17637.242     -17637.242      309.3349       309.3349       44128.375      44128.375      1287.5303      1287.5303    
     55000  -17471.656     -17471.656     -17637.719     -17637.719      321.25961      321.25961      44165.469      44165.469     -59.421721     -59.421721    
Loop time of 58.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.479 ns/day, 16.224 hours/ns, 17.122 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    | 58.253     | 58.253     | 58.253     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021277   | 0.021277   | 0.021277   |   0.0 |  0.04
Output  | 5.2459e-05 | 5.2459e-05 | 5.2459e-05 |   0.0 |  0.00
Modify  | 0.12042    | 0.12042    | 0.12042    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 314200
Ave neighs/atom = 78.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.418942422908, Press = -1.14265920228857
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17471.656     -17471.656     -17637.719     -17637.719      321.25961      321.25961      44165.469      44165.469     -59.421721     -59.421721    
     56000  -17478.995     -17478.995     -17638.422     -17638.422      308.42296      308.42296      44169.167      44169.167     -513.27361     -513.27361    
Loop time of 58.3078 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.482 ns/day, 16.197 hours/ns, 17.150 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    | 58.156     | 58.156     | 58.156     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021306   | 0.021306   | 0.021306   |   0.0 |  0.04
Output  | 3.7862e-05 | 3.7862e-05 | 3.7862e-05 |   0.0 |  0.00
Modify  | 0.12037    | 0.12037    | 0.12037    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 314060
Ave neighs/atom = 78.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378954493795, Press = -0.710935181855534
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17478.995     -17478.995     -17638.422     -17638.422      308.42296      308.42296      44169.167      44169.167     -513.27361     -513.27361    
     57000  -17473.149     -17473.149     -17636.083     -17636.083      315.20693      315.20693      44186.26       44186.26      -855.46847     -855.46847    
Loop time of 58.3436 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.207 hours/ns, 17.140 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    | 58.192     | 58.192     | 58.192     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021198   | 0.021198   | 0.021198   |   0.0 |  0.04
Output  | 4.3662e-05 | 4.3662e-05 | 4.3662e-05 |   0.0 |  0.00
Modify  | 0.12033    | 0.12033    | 0.12033    |   0.0 |  0.21
Other   |            | 0.01023    |            |       |  0.02

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

Total # of neighbors = 314098
Ave neighs/atom = 78.5245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.355169235234, Press = -0.584420467644335
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17473.149     -17473.149     -17636.083     -17636.083      315.20693      315.20693      44186.26       44186.26      -855.46847     -855.46847    
     58000  -17473.826     -17473.826     -17635.695     -17635.695      313.14687      313.14687      44187.564      44187.564     -875.71849     -875.71849    
Loop time of 58.4203 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.479 ns/day, 16.228 hours/ns, 17.117 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    | 58.268     | 58.268     | 58.268     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021237   | 0.021237   | 0.021237   |   0.0 |  0.04
Output  | 4.3943e-05 | 4.3943e-05 | 4.3943e-05 |   0.0 |  0.00
Modify  | 0.12035    | 0.12035    | 0.12035    |   0.0 |  0.21
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 313974
Ave neighs/atom = 78.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 = 313.327571253166, Press = -0.302056337622283
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
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17473.826     -17473.826     -17635.695     -17635.695      313.14687      313.14687      44187.564      44187.564     -875.71849     -875.71849    
     59000  -17474.164     -17474.164     -17635.093     -17635.093      311.32833      311.32833      44205.505      44205.505     -1609.0968     -1609.0968    
Loop time of 58.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.481 ns/day, 16.203 hours/ns, 17.144 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    | 58.177     | 58.177     | 58.177     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021244   | 0.021244   | 0.021244   |   0.0 |  0.04
Output  | 4.5205e-05 | 4.5205e-05 | 4.5205e-05 |   0.0 |  0.00
Modify  | 0.12035    | 0.12035    | 0.12035    |   0.0 |  0.21
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 314058
Ave neighs/atom = 78.5145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
44166.3762235491

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0