# 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 2.863645777106285*${_u_distance}
variable latticeconst_converted equal 2.863645777106285*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86364577710629
Lattice spacing in x,y,z = 2.8636458 2.8636458 2.8636458
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimLee_2006_PtFe__MO_343168101490_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_343168101490_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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8509.8399     -8509.8399     -8580.4194     -8580.4194      273.15         273.15         23483.233      23483.233      3210.2838      3210.2838    
      1000  -8436.3395     -8436.3395     -8504.0388     -8504.0388      262.0035       262.0035       23734.657      23734.657     -1570.3083     -1570.3083    
Loop time of 53.9387 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.602 ns/day, 14.983 hours/ns, 18.540 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    | 53.858     | 53.858     | 53.858     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015365   | 0.015365   | 0.015365   |   0.0 |  0.03
Output  | 0.00011277 | 0.00011277 | 0.00011277 |   0.0 |  0.00
Modify  | 0.060092   | 0.060092   | 0.060092   |   0.0 |  0.11
Other   |            | 0.00544    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       176000 ave      176000 max      176000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 176000
Ave neighs/atom = 88
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8436.3395     -8436.3395     -8504.0388     -8504.0388      262.0035       262.0035       23734.657      23734.657     -1570.3083     -1570.3083    
      2000  -8436.5125     -8436.5125     -8505.6925     -8505.6925      267.73354      267.73354      23709.968      23709.968     -26.550907     -26.550907    
Loop time of 59.4164 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.454 ns/day, 16.505 hours/ns, 16.830 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    | 59.337     | 59.337     | 59.337     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015094   | 0.015094   | 0.015094   |   0.0 |  0.03
Output  | 3.734e-05  | 3.734e-05  | 3.734e-05  |   0.0 |  0.00
Modify  | 0.059397   | 0.059397   | 0.059397   |   0.0 |  0.10
Other   |            | 0.005234   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191112 ave      191112 max      191112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191112
Ave neighs/atom = 95.556
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8436.5125     -8436.5125     -8505.6925     -8505.6925      267.73354      267.73354      23709.968      23709.968     -26.550907     -26.550907    
      3000  -8437.8435     -8437.8435     -8506.7127     -8506.7127      266.531        266.531        23700.481      23700.481      491.86829      491.86829    
Loop time of 59.8016 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.612 hours/ns, 16.722 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    | 59.722     | 59.722     | 59.722     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015049   | 0.015049   | 0.015049   |   0.0 |  0.03
Output  | 3.8543e-05 | 3.8543e-05 | 3.8543e-05 |   0.0 |  0.00
Modify  | 0.059519   | 0.059519   | 0.059519   |   0.0 |  0.10
Other   |            | 0.005208   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191696 ave      191696 max      191696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191696
Ave neighs/atom = 95.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8437.8435     -8437.8435     -8506.7127     -8506.7127      266.531        266.531        23700.481      23700.481      491.86829      491.86829    
      4000  -8435.1225     -8435.1225     -8506.4716     -8506.4716      276.12865      276.12865      23721.225      23721.225     -764.57994     -764.57994    
Loop time of 59.9163 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.643 hours/ns, 16.690 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    | 59.837     | 59.837     | 59.837     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015036   | 0.015036   | 0.015036   |   0.0 |  0.03
Output  | 3.7971e-05 | 3.7971e-05 | 3.7971e-05 |   0.0 |  0.00
Modify  | 0.059441   | 0.059441   | 0.059441   |   0.0 |  0.10
Other   |            | 0.005141   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192080 ave      192080 max      192080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192080
Ave neighs/atom = 96.04
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8435.1225     -8435.1225     -8506.4716     -8506.4716      276.12865      276.12865      23721.225      23721.225     -764.57994     -764.57994    
      5000  -8438.4525     -8438.4525     -8506.4627     -8506.4627      263.20682      263.20682      23687.763      23687.763      1310.5979      1310.5979    
Loop time of 59.7109 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.447 ns/day, 16.586 hours/ns, 16.747 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    | 59.631     | 59.631     | 59.631     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015031   | 0.015031   | 0.015031   |   0.0 |  0.03
Output  | 3.0848e-05 | 3.0848e-05 | 3.0848e-05 |   0.0 |  0.00
Modify  | 0.05953    | 0.05953    | 0.05953    |   0.0 |  0.10
Other   |            | 0.00512    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191678 ave      191678 max      191678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191678
Ave neighs/atom = 95.839
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.103000965696, Press = -535.050972757713
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8438.4525     -8438.4525     -8506.4627     -8506.4627      263.20682      263.20682      23687.763      23687.763      1310.5979      1310.5979    
      6000  -8436.4876     -8436.4876     -8506.6797     -8506.6797      271.65079      271.65079      23718.704      23718.704     -759.66627     -759.66627    
Loop time of 59.8271 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.619 hours/ns, 16.715 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    | 59.745     | 59.745     | 59.745     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.03
Output  | 3.1369e-05 | 3.1369e-05 | 3.1369e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.10
Other   |            | 0.005187   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192354 ave      192354 max      192354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192354
Ave neighs/atom = 96.177
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.661949226037, Press = 3.99038655441916
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8436.4876     -8436.4876     -8506.6797     -8506.6797      271.65079      271.65079      23718.704      23718.704     -759.66627     -759.66627    
      7000  -8441.7439     -8441.7439     -8506.973      -8506.973       252.44328      252.44328      23732.22       23732.22      -1972.8406     -1972.8406    
Loop time of 59.6872 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.580 hours/ns, 16.754 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    | 59.605     | 59.605     | 59.605     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.03
Output  | 3.0858e-05 | 3.0858e-05 | 3.0858e-05 |   0.0 |  0.00
Modify  | 0.061683   | 0.061683   | 0.061683   |   0.0 |  0.10
Other   |            | 0.005186   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191676 ave      191676 max      191676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191676
Ave neighs/atom = 95.838
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.433328753119, Press = -37.5397004435454
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8441.7439     -8441.7439     -8506.973      -8506.973       252.44328      252.44328      23732.22       23732.22      -1972.8406     -1972.8406    
      8000  -8435.4437     -8435.4437     -8507.1042     -8507.1042      277.3333       277.3333       23667.509      23667.509      3101.1726      3101.1726    
Loop time of 59.6553 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.571 hours/ns, 16.763 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    | 59.573     | 59.573     | 59.573     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 3.0768e-05 | 3.0768e-05 | 3.0768e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.10
Other   |            | 0.005175   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191434 ave      191434 max      191434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191434
Ave neighs/atom = 95.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.157335752623, Press = -21.1436631666461
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8435.4437     -8435.4437     -8507.1042     -8507.1042      277.3333       277.3333       23667.509      23667.509      3101.1726      3101.1726    
      9000  -8438.2872     -8438.2872     -8508.3704     -8508.3704      271.22949      271.22949      23706.059      23706.059     -41.569274     -41.569274    
Loop time of 59.8891 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.636 hours/ns, 16.698 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    | 59.807     | 59.807     | 59.807     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015042   | 0.015042   | 0.015042   |   0.0 |  0.03
Output  | 3.0297e-05 | 3.0297e-05 | 3.0297e-05 |   0.0 |  0.00
Modify  | 0.061716   | 0.061716   | 0.061716   |   0.0 |  0.10
Other   |            | 0.005169   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193002 ave      193002 max      193002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193002
Ave neighs/atom = 96.501
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.928230640017, Press = 6.11437114941831
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8438.2872     -8438.2872     -8508.3704     -8508.3704      271.22949      271.22949      23706.059      23706.059     -41.569274     -41.569274    
     10000  -8434.7076     -8434.7076     -8505.9178     -8505.9178      275.5911       275.5911       23728.951      23728.951     -1203.2661     -1203.2661    
Loop time of 59.9508 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.653 hours/ns, 16.680 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    | 59.869     | 59.869     | 59.869     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015129   | 0.015129   | 0.015129   |   0.0 |  0.03
Output  | 3.0397e-05 | 3.0397e-05 | 3.0397e-05 |   0.0 |  0.00
Modify  | 0.061826   | 0.061826   | 0.061826   |   0.0 |  0.10
Other   |            | 0.005177   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192122 ave      192122 max      192122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192122
Ave neighs/atom = 96.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.132948732578, Press = -11.5971523261739
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8434.7076     -8434.7076     -8505.9178     -8505.9178      275.5911       275.5911       23728.951      23728.951     -1203.2661     -1203.2661    
     11000  -8436.8126     -8436.8126     -8508.4529     -8508.4529      277.25526      277.25526      23686.407      23686.407      1384.3462      1384.3462    
Loop time of 59.7182 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.447 ns/day, 16.588 hours/ns, 16.745 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    | 59.636     | 59.636     | 59.636     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015057   | 0.015057   | 0.015057   |   0.0 |  0.03
Output  | 3.0628e-05 | 3.0628e-05 | 3.0628e-05 |   0.0 |  0.00
Modify  | 0.061841   | 0.061841   | 0.061841   |   0.0 |  0.10
Other   |            | 0.005177   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191466 ave      191466 max      191466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191466
Ave neighs/atom = 95.733
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.356489648205, Press = -8.4629254779524
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8436.8126     -8436.8126     -8508.4529     -8508.4529      277.25526      277.25526      23686.407      23686.407      1384.3462      1384.3462    
     12000  -8437.3713     -8437.3713     -8507.0633     -8507.0633      269.71507      269.71507      23701.651      23701.651      525.58343      525.58343    
Loop time of 59.8399 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.622 hours/ns, 16.711 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.758     | 59.758     | 59.758     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.03
Output  | 3.1029e-05 | 3.1029e-05 | 3.1029e-05 |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.10
Other   |            | 0.005156   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192846 ave      192846 max      192846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192846
Ave neighs/atom = 96.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.529234008022, Press = 2.4214848967005
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8437.3713     -8437.3713     -8507.0633     -8507.0633      269.71507      269.71507      23701.651      23701.651      525.58343      525.58343    
     13000  -8436.0671     -8436.0671     -8505.838      -8505.838       270.02067      270.02067      23760.731      23760.731     -3469.0669     -3469.0669    
Loop time of 59.6945 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.447 ns/day, 16.582 hours/ns, 16.752 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    | 59.613     | 59.613     | 59.613     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0151     | 0.0151     | 0.0151     |   0.0 |  0.03
Output  | 3.0347e-05 | 3.0347e-05 | 3.0347e-05 |   0.0 |  0.00
Modify  | 0.061603   | 0.061603   | 0.061603   |   0.0 |  0.10
Other   |            | 0.005167   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192354 ave      192354 max      192354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192354
Ave neighs/atom = 96.177
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.503040116605, Press = -8.53042449752318
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8436.0671     -8436.0671     -8505.838      -8505.838       270.02067      270.02067      23760.731      23760.731     -3469.0669     -3469.0669    
     14000  -8434.2206     -8434.2206     -8507.6449     -8507.6449      284.15962      284.15962      23676.065      23676.065      2355.212       2355.212     
Loop time of 59.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.566 hours/ns, 16.768 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    | 59.556     | 59.556     | 59.556     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.03
Output  | 3.0808e-05 | 3.0808e-05 | 3.0808e-05 |   0.0 |  0.00
Modify  | 0.061591   | 0.061591   | 0.061591   |   0.0 |  0.10
Other   |            | 0.005153   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       190932 ave      190932 max      190932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 190932
Ave neighs/atom = 95.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.540498618006, Press = -8.92469742733783
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8434.2206     -8434.2206     -8507.6449     -8507.6449      284.15962      284.15962      23676.065      23676.065      2355.212       2355.212     
     15000  -8439.2637     -8439.2637     -8509.4173     -8509.4173      271.50186      271.50186      23698.868      23698.868      254.66683      254.66683    
Loop time of 59.8105 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.614 hours/ns, 16.719 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    | 59.729     | 59.729     | 59.729     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015122   | 0.015122   | 0.015122   |   0.0 |  0.03
Output  | 3.0839e-05 | 3.0839e-05 | 3.0839e-05 |   0.0 |  0.00
Modify  | 0.061665   | 0.061665   | 0.061665   |   0.0 |  0.10
Other   |            | 0.005168   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192908 ave      192908 max      192908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192908
Ave neighs/atom = 96.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.601459267445, Press = -0.0414423271230114
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8439.2637     -8439.2637     -8509.4173     -8509.4173      271.50186      271.50186      23698.868      23698.868      254.66683      254.66683    
     16000  -8436.9404     -8436.9404     -8505.5704     -8505.5704      265.6052       265.6052       23717.659      23717.659     -381.97345     -381.97345    
Loop time of 59.9001 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.639 hours/ns, 16.694 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    | 59.818     | 59.818     | 59.818     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.03
Output  | 3.1179e-05 | 3.1179e-05 | 3.1179e-05 |   0.0 |  0.00
Modify  | 0.061771   | 0.061771   | 0.061771   |   0.0 |  0.10
Other   |            | 0.005179   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192422 ave      192422 max      192422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192422
Ave neighs/atom = 96.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.564155114803, Press = -1.67588527199968
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8436.9404     -8436.9404     -8505.5704     -8505.5704      265.6052       265.6052       23717.659      23717.659     -381.97345     -381.97345    
     17000  -8433.813      -8433.813      -8504.9579     -8504.9579      275.33797      275.33797      23706.788      23706.788      669.57623      669.57623    
Loop time of 59.9029 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.640 hours/ns, 16.694 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    | 59.821     | 59.821     | 59.821     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015148   | 0.015148   | 0.015148   |   0.0 |  0.03
Output  | 3.0607e-05 | 3.0607e-05 | 3.0607e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.10
Other   |            | 0.005201   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191836 ave      191836 max      191836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191836
Ave neighs/atom = 95.918
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.799979386421, Press = -4.4726078873704
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8433.813      -8433.813      -8504.9579     -8504.9579      275.33797      275.33797      23706.788      23706.788      669.57623      669.57623    
     18000  -8437.0985     -8437.0985     -8508.3994     -8508.3994      275.94206      275.94206      23686.673      23686.673      1448.0414      1448.0414    
Loop time of 59.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.623 hours/ns, 16.711 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.76      | 59.76      | 59.76      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.03
Output  | 3.0467e-05 | 3.0467e-05 | 3.0467e-05 |   0.0 |  0.00
Modify  | 0.061732   | 0.061732   | 0.061732   |   0.0 |  0.10
Other   |            | 0.005177   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191862 ave      191862 max      191862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191862
Ave neighs/atom = 95.931
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.928925626725, Press = -0.705305089910774
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8437.0985     -8437.0985     -8508.3994     -8508.3994      275.94206      275.94206      23686.673      23686.673      1448.0414      1448.0414    
     19000  -8435.395      -8435.395      -8506.5449     -8506.5449      275.3575       275.3575       23740.884      23740.884     -2047.4286     -2047.4286    
Loop time of 59.6764 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.577 hours/ns, 16.757 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    | 59.594     | 59.594     | 59.594     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.03
Output  | 3.1118e-05 | 3.1118e-05 | 3.1118e-05 |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.10
Other   |            | 0.005166   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192610 ave      192610 max      192610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192610
Ave neighs/atom = 96.305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.978471984053, Press = 0.45708862975602
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8435.395      -8435.395      -8506.5449     -8506.5449      275.3575       275.3575       23740.884      23740.884     -2047.4286     -2047.4286    
     20000  -8439.7768     -8439.7768     -8507.2419     -8507.2419      261.09712      261.09712      23712.004      23712.004     -484.04972     -484.04972    
Loop time of 59.6309 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.564 hours/ns, 16.770 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    | 59.549     | 59.549     | 59.549     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.03
Output  | 3.0327e-05 | 3.0327e-05 | 3.0327e-05 |   0.0 |  0.00
Modify  | 0.061654   | 0.061654   | 0.061654   |   0.0 |  0.10
Other   |            | 0.005158   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191290 ave      191290 max      191290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191290
Ave neighs/atom = 95.645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.89063034144, Press = -7.40103949739663
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8439.7768     -8439.7768     -8507.2419     -8507.2419      261.09712      261.09712      23712.004      23712.004     -484.04972     -484.04972    
     21000  -8434.2919     -8434.2919     -8507.6153     -8507.6153      283.76889      283.76889      23685.307      23685.307      1692.167       1692.167     
Loop time of 59.7804 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.606 hours/ns, 16.728 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    | 59.699     | 59.699     | 59.699     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.03
Output  | 3.0487e-05 | 3.0487e-05 | 3.0487e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.10
Other   |            | 0.005182   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191856 ave      191856 max      191856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191856
Ave neighs/atom = 95.928
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.861230648309, Press = -1.66238783705882
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8434.2919     -8434.2919     -8507.6153     -8507.6153      283.76889      283.76889      23685.307      23685.307      1692.167       1692.167     
     22000  -8436.5642     -8436.5642     -8507.4919     -8507.4919      274.49735      274.49735      23723.578      23723.578     -1175.2741     -1175.2741    
Loop time of 59.8249 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.618 hours/ns, 16.715 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    | 59.743     | 59.743     | 59.743     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.03
Output  | 3.0598e-05 | 3.0598e-05 | 3.0598e-05 |   0.0 |  0.00
Modify  | 0.061656   | 0.061656   | 0.061656   |   0.0 |  0.10
Other   |            | 0.005176   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192690 ave      192690 max      192690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192690
Ave neighs/atom = 96.345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.834958316435, Press = -0.637719440146409
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8436.5642     -8436.5642     -8507.4919     -8507.4919      274.49735      274.49735      23723.578      23723.578     -1175.2741     -1175.2741    
     23000  -8435.5869     -8435.5869     -8506.7698     -8506.7698      275.48499      275.48499      23717.519      23717.519     -566.07925     -566.07925    
Loop time of 59.8057 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.613 hours/ns, 16.721 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    | 59.724     | 59.724     | 59.724     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015105   | 0.015105   | 0.015105   |   0.0 |  0.03
Output  | 3.0177e-05 | 3.0177e-05 | 3.0177e-05 |   0.0 |  0.00
Modify  | 0.061773   | 0.061773   | 0.061773   |   0.0 |  0.10
Other   |            | 0.005193   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191558 ave      191558 max      191558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191558
Ave neighs/atom = 95.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.818341619661, Press = -3.06516052442827
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8435.5869     -8435.5869     -8506.7698     -8506.7698      275.48499      275.48499      23717.519      23717.519     -566.07925     -566.07925    
     24000  -8438.8057     -8438.8057     -8508.8665     -8508.8665      271.14256      271.14256      23693.632      23693.632      699.84891      699.84891    
Loop time of 59.9989 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.666 hours/ns, 16.667 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    | 59.917     | 59.917     | 59.917     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.03
Output  | 2.9997e-05 | 2.9997e-05 | 2.9997e-05 |   0.0 |  0.00
Modify  | 0.06182    | 0.06182    | 0.06182    |   0.0 |  0.10
Other   |            | 0.005184   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191806 ave      191806 max      191806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191806
Ave neighs/atom = 95.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785951638367, Press = -1.00693647964873
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8438.8057     -8438.8057     -8508.8665     -8508.8665      271.14256      271.14256      23693.632      23693.632      699.84891      699.84891    
     25000  -8436.376      -8436.376      -8507.4078     -8507.4078      274.9004       274.9004       23715.262      23715.262     -452.86228     -452.86228    
Loop time of 59.9067 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.641 hours/ns, 16.693 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 59.825     | 59.825     | 59.825     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015049   | 0.015049   | 0.015049   |   0.0 |  0.03
Output  | 3.1649e-05 | 3.1649e-05 | 3.1649e-05 |   0.0 |  0.00
Modify  | 0.061755   | 0.061755   | 0.061755   |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192398 ave      192398 max      192398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192398
Ave neighs/atom = 96.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.815847727516, Press = -2.19192119362122
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8436.376      -8436.376      -8507.4078     -8507.4078      274.9004       274.9004       23715.262      23715.262     -452.86228     -452.86228    
     26000  -8438.4127     -8438.4127     -8506.6517     -8506.6517      264.09227      264.09227      23697.564      23697.564      692.99092      692.99092    
Loop time of 59.6618 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.573 hours/ns, 16.761 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    | 59.58      | 59.58      | 59.58      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015152   | 0.015152   | 0.015152   |   0.0 |  0.03
Output  | 2.9996e-05 | 2.9996e-05 | 2.9996e-05 |   0.0 |  0.00
Modify  | 0.06162    | 0.06162    | 0.06162    |   0.0 |  0.10
Other   |            | 0.00516    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191990 ave      191990 max      191990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191990
Ave neighs/atom = 95.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.786711976914, Press = -2.14273167315194
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8438.4127     -8438.4127     -8506.6517     -8506.6517      264.09227      264.09227      23697.564      23697.564      692.99092      692.99092    
     27000  -8437.0038     -8437.0038     -8506.6689     -8506.6689      269.61124      269.61124      23705.594      23705.594      309.83596      309.83596    
Loop time of 59.6567 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.571 hours/ns, 16.763 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    | 59.575     | 59.575     | 59.575     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 3.0998e-05 | 3.0998e-05 | 3.0998e-05 |   0.0 |  0.00
Modify  | 0.061622   | 0.061622   | 0.061622   |   0.0 |  0.10
Other   |            | 0.005155   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192316 ave      192316 max      192316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192316
Ave neighs/atom = 96.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792105388703, Press = -1.21372236113614
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8437.0038     -8437.0038     -8506.6689     -8506.6689      269.61124      269.61124      23705.594      23705.594      309.83596      309.83596    
     28000  -8433.8751     -8433.8751     -8508.0302     -8508.0302      286.98809      286.98809      23738.662      23738.662     -2077.9029     -2077.9029    
Loop time of 59.7677 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.602 hours/ns, 16.731 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    | 59.686     | 59.686     | 59.686     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.03
Output  | 3.1159e-05 | 3.1159e-05 | 3.1159e-05 |   0.0 |  0.00
Modify  | 0.061655   | 0.061655   | 0.061655   |   0.0 |  0.10
Other   |            | 0.005193   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192124 ave      192124 max      192124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192124
Ave neighs/atom = 96.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.766683497567, Press = -2.75683473911351
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8433.8751     -8433.8751     -8508.0302     -8508.0302      286.98809      286.98809      23738.662      23738.662     -2077.9029     -2077.9029    
     29000  -8437.7226     -8437.7226     -8506.4301     -8506.4301      265.90517      265.90517      23652.979      23652.979      4104.8249      4104.8249    
Loop time of 59.6729 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.576 hours/ns, 16.758 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    | 59.591     | 59.591     | 59.591     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015168   | 0.015168   | 0.015168   |   0.0 |  0.03
Output  | 3.0398e-05 | 3.0398e-05 | 3.0398e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.10
Other   |            | 0.005174   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191486 ave      191486 max      191486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191486
Ave neighs/atom = 95.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.768170057872, Press = -2.9592115930961
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8437.7226     -8437.7226     -8506.4301     -8506.4301      265.90517      265.90517      23652.979      23652.979      4104.8249      4104.8249    
     30000  -8439.0447     -8439.0447     -8508.2895     -8508.2895      267.9842       267.9842       23706.188      23706.188     -47.739254     -47.739254    
Loop time of 60.0777 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.438 ns/day, 16.688 hours/ns, 16.645 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    | 59.996     | 59.996     | 59.996     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.02
Output  | 2.9646e-05 | 2.9646e-05 | 2.9646e-05 |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.10
Other   |            | 0.00518    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193146 ave      193146 max      193146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193146
Ave neighs/atom = 96.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.784431641957, Press = 1.19950005141485
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8439.0447     -8439.0447     -8508.2895     -8508.2895      267.9842       267.9842       23706.188      23706.188     -47.739254     -47.739254    
     31000  -8437.055      -8437.055      -8507.7354     -8507.7354      273.54052      273.54052      23729.527      23729.527     -1622.5422     -1622.5422    
Loop time of 59.8915 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.637 hours/ns, 16.697 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    | 59.809     | 59.809     | 59.809     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01504    | 0.01504    | 0.01504    |   0.0 |  0.03
Output  | 3.0067e-05 | 3.0067e-05 | 3.0067e-05 |   0.0 |  0.00
Modify  | 0.061858   | 0.061858   | 0.061858   |   0.0 |  0.10
Other   |            | 0.005189   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192182 ave      192182 max      192182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192182
Ave neighs/atom = 96.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.696163073576, Press = -2.34860950849024
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8437.055      -8437.055      -8507.7354     -8507.7354      273.54052      273.54052      23729.527      23729.527     -1622.5422     -1622.5422    
     32000  -8437.9311     -8437.9311     -8507.3035     -8507.3035      268.47835      268.47835      23689.73       23689.73       1331.8413      1331.8413    
Loop time of 59.6517 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.570 hours/ns, 16.764 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    | 59.57      | 59.57      | 59.57      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015047   | 0.015047   | 0.015047   |   0.0 |  0.03
Output  | 3.0688e-05 | 3.0688e-05 | 3.0688e-05 |   0.0 |  0.00
Modify  | 0.061749   | 0.061749   | 0.061749   |   0.0 |  0.10
Other   |            | 0.005158   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191386 ave      191386 max      191386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191386
Ave neighs/atom = 95.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.715039288166, Press = -2.20371956187059
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8437.9311     -8437.9311     -8507.3035     -8507.3035      268.47835      268.47835      23689.73       23689.73       1331.8413      1331.8413    
     33000  -8434.0169     -8434.0169     -8503.5056     -8503.5056      268.92835      268.92835      23693.1        23693.1        1638.3557      1638.3557    
Loop time of 59.8158 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.616 hours/ns, 16.718 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    | 59.734     | 59.734     | 59.734     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.03
Output  | 3.0708e-05 | 3.0708e-05 | 3.0708e-05 |   0.0 |  0.00
Modify  | 0.061665   | 0.061665   | 0.061665   |   0.0 |  0.10
Other   |            | 0.005162   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192422 ave      192422 max      192422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192422
Ave neighs/atom = 96.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792693077966, Press = 0.790336606164837
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8434.0169     -8434.0169     -8503.5056     -8503.5056      268.92835      268.92835      23693.1        23693.1        1638.3557      1638.3557    
     34000  -8437.8244     -8437.8244     -8507.1879     -8507.1879      268.44367      268.44367      23755.648      23755.648     -3544.5633     -3544.5633    
Loop time of 59.7927 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.609 hours/ns, 16.724 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    | 59.711     | 59.711     | 59.711     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.03
Output  | 3.0297e-05 | 3.0297e-05 | 3.0297e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.10
Other   |            | 0.005164   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192368 ave      192368 max      192368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192368
Ave neighs/atom = 96.184
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.757347604666, Press = -1.54280257248645
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8437.8244     -8437.8244     -8507.1879     -8507.1879      268.44367      268.44367      23755.648      23755.648     -3544.5633     -3544.5633    
     35000  -8434.8661     -8434.8661     -8506.7433     -8506.7433      278.17237      278.17237      23703.179      23703.179      461.01682      461.01682    
Loop time of 59.6453 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.568 hours/ns, 16.766 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    | 59.563     | 59.563     | 59.563     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.03
Output  | 3.0638e-05 | 3.0638e-05 | 3.0638e-05 |   0.0 |  0.00
Modify  | 0.061652   | 0.061652   | 0.061652   |   0.0 |  0.10
Other   |            | 0.005173   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       190970 ave      190970 max      190970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 190970
Ave neighs/atom = 95.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.700225442402, Press = -2.91486119909374
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8434.8661     -8434.8661     -8506.7433     -8506.7433      278.17237      278.17237      23703.179      23703.179      461.01682      461.01682    
     36000  -8435.7211     -8435.7211     -8507.641      -8507.641       278.33751      278.33751      23702.882      23702.882      355.9467       355.9467     
Loop time of 59.8493 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.625 hours/ns, 16.709 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    | 59.767     | 59.767     | 59.767     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.03
Output  | 3.1068e-05 | 3.1068e-05 | 3.1068e-05 |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.10
Other   |            | 0.005164   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192068 ave      192068 max      192068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192068
Ave neighs/atom = 96.034
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.71358180558, Press = -0.438031621504389
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8435.7211     -8435.7211     -8507.641      -8507.641       278.33751      278.33751      23702.882      23702.882      355.9467       355.9467     
     37000  -8437.3317     -8437.3317     -8506.546      -8506.546       267.86658      267.86658      23715.013      23715.013     -345.43267     -345.43267    
Loop time of 59.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.441 ns/day, 16.661 hours/ns, 16.673 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    | 59.896     | 59.896     | 59.896     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015024   | 0.015024   | 0.015024   |   0.0 |  0.03
Output  | 3.0317e-05 | 3.0317e-05 | 3.0317e-05 |   0.0 |  0.00
Modify  | 0.061885   | 0.061885   | 0.061885   |   0.0 |  0.10
Other   |            | 0.005177   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192180 ave      192180 max      192180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192180
Ave neighs/atom = 96.09
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.801748040214, Press = -0.855210134637559
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8437.3317     -8437.3317     -8506.546      -8506.546       267.86658      267.86658      23715.013      23715.013     -345.43267     -345.43267    
     38000  -8438.4296     -8438.4296     -8507.7973     -8507.7973      268.46025      268.46025      23716.651      23716.651     -762.69671     -762.69671    
Loop time of 59.8774 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.633 hours/ns, 16.701 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    | 59.795     | 59.795     | 59.795     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.03
Output  | 2.9767e-05 | 2.9767e-05 | 2.9767e-05 |   0.0 |  0.00
Modify  | 0.061811   | 0.061811   | 0.061811   |   0.0 |  0.10
Other   |            | 0.005179   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191716 ave      191716 max      191716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191716
Ave neighs/atom = 95.858
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.855990758683, Press = -2.17031758301498
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8438.4296     -8438.4296     -8507.7973     -8507.7973      268.46025      268.46025      23716.651      23716.651     -762.69671     -762.69671    
     39000  -8432.3411     -8432.3411     -8504.4556     -8504.4556      279.0908       279.0908       23657.297      23657.297      4185.5213      4185.5213    
Loop time of 59.6755 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.577 hours/ns, 16.757 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    | 59.594     | 59.594     | 59.594     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.03
Output  | 3.0578e-05 | 3.0578e-05 | 3.0578e-05 |   0.0 |  0.00
Modify  | 0.061732   | 0.061732   | 0.061732   |   0.0 |  0.10
Other   |            | 0.005175   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191796 ave      191796 max      191796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191796
Ave neighs/atom = 95.898
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.915420791234, Press = -0.674518883221114
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8432.3411     -8432.3411     -8504.4556     -8504.4556      279.0908       279.0908       23657.297      23657.297      4185.5213      4185.5213    
     40000  -8436.6666     -8436.6666     -8505.9839     -8505.9839      268.26521      268.26521      23730.722      23730.722     -1471.5635     -1471.5635    
Loop time of 59.9204 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.645 hours/ns, 16.689 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    | 59.839     | 59.839     | 59.839     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.02
Output  | 3.1048e-05 | 3.1048e-05 | 3.1048e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.10
Other   |            | 0.005152   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193016 ave      193016 max      193016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193016
Ave neighs/atom = 96.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.951964161203, Press = 0.892514697617888
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8436.6666     -8436.6666     -8505.9839     -8505.9839      268.26521      268.26521      23730.722      23730.722     -1471.5635     -1471.5635    
     41000  -8437.0083     -8437.0083     -8508.3794     -8508.3794      276.21366      276.21366      23721.254      23721.254     -1213.4451     -1213.4451    
Loop time of 59.6616 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.573 hours/ns, 16.761 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    | 59.58      | 59.58      | 59.58      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014969   | 0.014969   | 0.014969   |   0.0 |  0.03
Output  | 2.9997e-05 | 2.9997e-05 | 2.9997e-05 |   0.0 |  0.00
Modify  | 0.061655   | 0.061655   | 0.061655   |   0.0 |  0.10
Other   |            | 0.005161   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191350 ave      191350 max      191350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191350
Ave neighs/atom = 95.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.98424704161, Press = -2.26866608487316
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8437.0083     -8437.0083     -8508.3794     -8508.3794      276.21366      276.21366      23721.254      23721.254     -1213.4451     -1213.4451    
     42000  -8434.1901     -8434.1901     -8506.6137     -8506.6137      280.28689      280.28689      23686.781      23686.781      1675.6409      1675.6409    
Loop time of 59.7701 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.603 hours/ns, 16.731 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    | 59.688     | 59.688     | 59.688     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014936   | 0.014936   | 0.014936   |   0.0 |  0.02
Output  | 3.3233e-05 | 3.3233e-05 | 3.3233e-05 |   0.0 |  0.00
Modify  | 0.06166    | 0.06166    | 0.06166    |   0.0 |  0.10
Other   |            | 0.005169   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191558 ave      191558 max      191558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191558
Ave neighs/atom = 95.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.99540946954, Press = -0.697009673540201
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8434.1901     -8434.1901     -8506.6137     -8506.6137      280.28689      280.28689      23686.781      23686.781      1675.6409      1675.6409    
     43000  -8437.4082     -8437.4082     -8507.9596     -8507.9596      273.04132      273.04132      23723.114      23723.114     -1255.9326     -1255.9326    
Loop time of 59.7558 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.599 hours/ns, 16.735 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    | 59.674     | 59.674     | 59.674     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015065   | 0.015065   | 0.015065   |   0.0 |  0.03
Output  | 3.0748e-05 | 3.0748e-05 | 3.0748e-05 |   0.0 |  0.00
Modify  | 0.061648   | 0.061648   | 0.061648   |   0.0 |  0.10
Other   |            | 0.005162   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192432 ave      192432 max      192432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192432
Ave neighs/atom = 96.216
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.077624478052, Press = -0.33302051032126
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8437.4082     -8437.4082     -8507.9596     -8507.9596      273.04132      273.04132      23723.114      23723.114     -1255.9326     -1255.9326    
     44000  -8434.5128     -8434.5128     -8506.2117     -8506.2117      277.4821       277.4821       23728.433      23728.433     -1166.2563     -1166.2563    
Loop time of 59.7973 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.610 hours/ns, 16.723 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    | 59.715     | 59.715     | 59.715     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.03
Output  | 3.0437e-05 | 3.0437e-05 | 3.0437e-05 |   0.0 |  0.00
Modify  | 0.061823   | 0.061823   | 0.061823   |   0.0 |  0.10
Other   |            | 0.005166   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191842 ave      191842 max      191842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191842
Ave neighs/atom = 95.921
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.074833067501, Press = -1.94912382093312
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8434.5128     -8434.5128     -8506.2117     -8506.2117      277.4821       277.4821       23728.433      23728.433     -1166.2563     -1166.2563    
     45000  -8438.3715     -8438.3715     -8508.2454     -8508.2454      270.41891      270.41891      23653.155      23653.155      3733.3529      3733.3529    
Loop time of 59.8535 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.626 hours/ns, 16.707 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    | 59.771     | 59.771     | 59.771     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.03
Output  | 5.271e-05  | 5.271e-05  | 5.271e-05  |   0.0 |  0.00
Modify  | 0.061831   | 0.061831   | 0.061831   |   0.0 |  0.10
Other   |            | 0.005171   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191618 ave      191618 max      191618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191618
Ave neighs/atom = 95.809
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.102433018711, Press = -1.14931021397758
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8438.3715     -8438.3715     -8508.2454     -8508.2454      270.41891      270.41891      23653.155      23653.155      3733.3529      3733.3529    
     46000  -8437.5443     -8437.5443     -8509.2395     -8509.2395      277.4678       277.4678       23716.073      23716.073     -900.95232     -900.95232    
Loop time of 59.9372 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.649 hours/ns, 16.684 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    | 59.855     | 59.855     | 59.855     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015121   | 0.015121   | 0.015121   |   0.0 |  0.03
Output  | 3.1078e-05 | 3.1078e-05 | 3.1078e-05 |   0.0 |  0.00
Modify  | 0.061649   | 0.061649   | 0.061649   |   0.0 |  0.10
Other   |            | 0.005163   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193352 ave      193352 max      193352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193352
Ave neighs/atom = 96.676
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.09512343448, Press = 1.0221021280912
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8437.5443     -8437.5443     -8509.2395     -8509.2395      277.4678       277.4678       23716.073      23716.073     -900.95232     -900.95232    
     47000  -8435.7261     -8435.7261     -8506.1688     -8506.1688      272.62018      272.62018      23726.581      23726.581     -1134.9768     -1134.9768    
Loop time of 59.7589 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.600 hours/ns, 16.734 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    | 59.677     | 59.677     | 59.677     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.02
Output  | 3.0257e-05 | 3.0257e-05 | 3.0257e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.10
Other   |            | 0.005158   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191790 ave      191790 max      191790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191790
Ave neighs/atom = 95.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.040500525196, Press = -1.2941359781446
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8435.7261     -8435.7261     -8506.1688     -8506.1688      272.62018      272.62018      23726.581      23726.581     -1134.9768     -1134.9768    
     48000  -8436.971      -8436.971      -8507.1103     -8507.1103      271.44637      271.44637      23691.791      23691.791      1131.6043      1131.6043    
Loop time of 59.6649 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.574 hours/ns, 16.760 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    | 59.583     | 59.583     | 59.583     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015076   | 0.015076   | 0.015076   |   0.0 |  0.03
Output  | 2.9836e-05 | 2.9836e-05 | 2.9836e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.10
Other   |            | 0.005159   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191542 ave      191542 max      191542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191542
Ave neighs/atom = 95.771
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.019893859358, Press = -1.06854622783484
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8436.971      -8436.971      -8507.1103     -8507.1103      271.44637      271.44637      23691.791      23691.791      1131.6043      1131.6043    
     49000  -8440.0823     -8440.0823     -8508.6893     -8508.6893      265.51645      265.51645      23696.434      23696.434      557.91642      557.91642    
Loop time of 59.774 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.604 hours/ns, 16.730 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    | 59.692     | 59.692     | 59.692     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015092   | 0.015092   | 0.015092   |   0.0 |  0.03
Output  | 2.7422e-05 | 2.7422e-05 | 2.7422e-05 |   0.0 |  0.00
Modify  | 0.06168    | 0.06168    | 0.06168    |   0.0 |  0.10
Other   |            | 0.005166   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192440 ave      192440 max      192440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192440
Ave neighs/atom = 96.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946054151127, Press = 0.277582116277373
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8440.0823     -8440.0823     -8508.6893     -8508.6893      265.51645      265.51645      23696.434      23696.434      557.91642      557.91642    
     50000  -8436.5068     -8436.5068     -8504.0301     -8504.0301      261.32234      261.32234      23747.227      23747.227     -2284.7827     -2284.7827    
Loop time of 59.9839 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.440 ns/day, 16.662 hours/ns, 16.671 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    | 59.902     | 59.902     | 59.902     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015053   | 0.015053   | 0.015053   |   0.0 |  0.03
Output  | 2.7372e-05 | 2.7372e-05 | 2.7372e-05 |   0.0 |  0.00
Modify  | 0.061835   | 0.061835   | 0.061835   |   0.0 |  0.10
Other   |            | 0.005168   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192556 ave      192556 max      192556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192556
Ave neighs/atom = 96.278
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.934832173702, Press = -1.29146347197373
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8436.5068     -8436.5068     -8504.0301     -8504.0301      261.32234      261.32234      23747.227      23747.227     -2284.7827     -2284.7827    
     51000  -8439.9858     -8439.9858     -8508.0409     -8508.0409      263.38027      263.38027      23662.342      23662.342      3058.8495      3058.8495    
Loop time of 59.8058 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.613 hours/ns, 16.721 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    | 59.724     | 59.724     | 59.724     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015075   | 0.015075   | 0.015075   |   0.0 |  0.03
Output  | 2.7602e-05 | 2.7602e-05 | 2.7602e-05 |   0.0 |  0.00
Modify  | 0.061744   | 0.061744   | 0.061744   |   0.0 |  0.10
Other   |            | 0.005184   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191054 ave      191054 max      191054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191054
Ave neighs/atom = 95.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.890748133101, Press = -2.46902555397647
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8439.9858     -8439.9858     -8508.0409     -8508.0409      263.38027      263.38027      23662.342      23662.342      3058.8495      3058.8495    
     52000  -8435.4803     -8435.4803     -8505.647      -8505.647       271.55265      271.55265      23695.548      23695.548      1224.8818      1224.8818    
Loop time of 59.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.445 ns/day, 16.612 hours/ns, 16.721 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    | 59.722     | 59.722     | 59.722     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.03
Output  | 2.7913e-05 | 2.7913e-05 | 2.7913e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.005153   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193216 ave      193216 max      193216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193216
Ave neighs/atom = 96.608
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.88336981893, Press = 0.204089410897714
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8435.4803     -8435.4803     -8505.647      -8505.647       271.55265      271.55265      23695.548      23695.548      1224.8818      1224.8818    
     53000  -8437.9953     -8437.9953     -8509.3766     -8509.3766      276.25281      276.25281      23722.467      23722.467     -1377.5135     -1377.5135    
Loop time of 59.7362 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.593 hours/ns, 16.740 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    | 59.654     | 59.654     | 59.654     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015043   | 0.015043   | 0.015043   |   0.0 |  0.03
Output  | 2.7633e-05 | 2.7633e-05 | 2.7633e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.10
Other   |            | 0.005154   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192172 ave      192172 max      192172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192172
Ave neighs/atom = 96.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.851696548514, Press = -0.558540039765053
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8437.9953     -8437.9953     -8509.3766     -8509.3766      276.25281      276.25281      23722.467      23722.467     -1377.5135     -1377.5135    
     54000  -8435.5643     -8435.5643     -8507.6133     -8507.6133      278.83685      278.83685      23696.375      23696.375      821.64966      821.64966    
Loop time of 59.6647 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.574 hours/ns, 16.760 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    | 59.583     | 59.583     | 59.583     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.03
Output  | 2.9957e-05 | 2.9957e-05 | 2.9957e-05 |   0.0 |  0.00
Modify  | 0.061593   | 0.061593   | 0.061593   |   0.0 |  0.10
Other   |            | 0.005148   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191624 ave      191624 max      191624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191624
Ave neighs/atom = 95.812
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.865116349348, Press = -0.922358971345002
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8435.5643     -8435.5643     -8507.6133     -8507.6133      278.83685      278.83685      23696.375      23696.375      821.64966      821.64966    
     55000  -8435.4654     -8435.4654     -8505.7422     -8505.7422      271.97826      271.97826      23711.784      23711.784      56.245289      56.245289    
Loop time of 59.5671 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.450 ns/day, 16.546 hours/ns, 16.788 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    | 59.485     | 59.485     | 59.485     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.03
Output  | 2.6891e-05 | 2.6891e-05 | 2.6891e-05 |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.10
Other   |            | 0.005161   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192210 ave      192210 max      192210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192210
Ave neighs/atom = 96.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.86074495316, Press = -0.198436268373212
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8435.4654     -8435.4654     -8505.7422     -8505.7422      271.97826      271.97826      23711.784      23711.784      56.245289      56.245289    
     56000  -8441.3746     -8441.3746     -8509.9226     -8509.9226      265.28789      265.28789      23722.387      23722.387     -1558.6729     -1558.6729    
Loop time of 59.6432 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.449 ns/day, 16.568 hours/ns, 16.766 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    | 59.561     | 59.561     | 59.561     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015056   | 0.015056   | 0.015056   |   0.0 |  0.03
Output  | 3.0658e-05 | 3.0658e-05 | 3.0658e-05 |   0.0 |  0.00
Modify  | 0.06159    | 0.06159    | 0.06159    |   0.0 |  0.10
Other   |            | 0.005158   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192006 ave      192006 max      192006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192006
Ave neighs/atom = 96.003
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.847768962981, Press = -1.38380255214027
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8441.3746     -8441.3746     -8509.9226     -8509.9226      265.28789      265.28789      23722.387      23722.387     -1558.6729     -1558.6729    
     57000  -8435.4623     -8435.4623     -8508.3261     -8508.3261      281.99057      281.99057      23676.723      23676.723      2219.487       2219.487     
Loop time of 59.8272 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.619 hours/ns, 16.715 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    | 59.745     | 59.745     | 59.745     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01514    | 0.01514    | 0.01514    |   0.0 |  0.03
Output  | 2.7623e-05 | 2.7623e-05 | 2.7623e-05 |   0.0 |  0.00
Modify  | 0.061792   | 0.061792   | 0.061792   |   0.0 |  0.10
Other   |            | 0.00519    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191642 ave      191642 max      191642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191642
Ave neighs/atom = 95.821
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.818029458049, Press = -1.0837436294517
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8435.4623     -8435.4623     -8508.3261     -8508.3261      281.99057      281.99057      23676.723      23676.723      2219.487       2219.487     
     58000  -8440.0981     -8440.0981     -8508.3342     -8508.3342      264.08062      264.08062      23701.071      23701.071      274.16303      274.16303    
Loop time of 60.0286 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.439 ns/day, 16.675 hours/ns, 16.659 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    | 59.947     | 59.947     | 59.947     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.03
Output  | 2.7672e-05 | 2.7672e-05 | 2.7672e-05 |   0.0 |  0.00
Modify  | 0.061849   | 0.061849   | 0.061849   |   0.0 |  0.10
Other   |            | 0.00516    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192954 ave      192954 max      192954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192954
Ave neighs/atom = 96.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802199993312, Press = 1.04258957703181
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8440.0981     -8440.0981     -8508.3342     -8508.3342      264.08062      264.08062      23701.071      23701.071      274.16303      274.16303    
     59000  -8436.3745     -8436.3745     -8506.3488     -8506.3488      270.80801      270.80801      23739.017      23739.017     -2049.2137     -2049.2137    
Loop time of 59.8547 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.626 hours/ns, 16.707 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    | 59.773     | 59.773     | 59.773     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014901   | 0.014901   | 0.014901   |   0.0 |  0.02
Output  | 2.8594e-05 | 2.8594e-05 | 2.8594e-05 |   0.0 |  0.00
Modify  | 0.061686   | 0.061686   | 0.061686   |   0.0 |  0.10
Other   |            | 0.005254   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192206 ave      192206 max      192206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192206
Ave neighs/atom = 96.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.761832903383, Press = -1.0005223882036
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8436.3745     -8436.3745     -8506.3488     -8506.3488      270.80801      270.80801      23739.017      23739.017     -2049.2137     -2049.2137    
     60000  -8437.2945     -8437.2945     -8508.734      -8508.734       276.47857      276.47857      23691.034      23691.034      989.56029      989.56029    
Loop time of 59.5164 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.452 ns/day, 16.532 hours/ns, 16.802 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    | 59.435     | 59.435     | 59.435     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01485    | 0.01485    | 0.01485    |   0.0 |  0.02
Output  | 2.7382e-05 | 2.7382e-05 | 2.7382e-05 |   0.0 |  0.00
Modify  | 0.061622   | 0.061622   | 0.061622   |   0.0 |  0.10
Other   |            | 0.0053     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191430 ave      191430 max      191430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191430
Ave neighs/atom = 95.715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.811946658536, Press = -1.03599460767705
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8437.2945     -8437.2945     -8508.734      -8508.734       276.47857      276.47857      23691.034      23691.034      989.56029      989.56029    
     61000  -8436.6053     -8436.6053     -8507.7239     -8507.7239      275.23633      275.23633      23705.51       23705.51       96.234766      96.234766    
Loop time of 59.6817 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.578 hours/ns, 16.756 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    | 59.6       | 59.6       | 59.6       |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014859   | 0.014859   | 0.014859   |   0.0 |  0.02
Output  | 2.7192e-05 | 2.7192e-05 | 2.7192e-05 |   0.0 |  0.00
Modify  | 0.061551   | 0.061551   | 0.061551   |   0.0 |  0.10
Other   |            | 0.005338   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192500 ave      192500 max      192500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192500
Ave neighs/atom = 96.25
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822111035379, Press = 0.187438641875541
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8436.6053     -8436.6053     -8507.7239     -8507.7239      275.23633      275.23633      23705.51       23705.51       96.234766      96.234766    
     62000  -8437.4023     -8437.4023     -8509.6478     -8509.6478      279.59768      279.59768      23745.123      23745.123     -3042.2305     -3042.2305    
Loop time of 59.6827 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.579 hours/ns, 16.755 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    | 59.601     | 59.601     | 59.601     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014868   | 0.014868   | 0.014868   |   0.0 |  0.02
Output  | 2.7361e-05 | 2.7361e-05 | 2.7361e-05 |   0.0 |  0.00
Modify  | 0.061597   | 0.061597   | 0.061597   |   0.0 |  0.10
Other   |            | 0.005274   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191982 ave      191982 max      191982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191982
Ave neighs/atom = 95.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.845341497271, Press = -0.625810418074743
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8437.4023     -8437.4023     -8509.6478     -8509.6478      279.59768      279.59768      23745.123      23745.123     -3042.2305     -3042.2305    
     63000  -8433.0831     -8433.0831     -8503.409      -8503.409       272.16836      272.16836      23696.282      23696.282      1568.2893      1568.2893    
Loop time of 59.5922 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.450 ns/day, 16.553 hours/ns, 16.781 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    | 59.51      | 59.51      | 59.51      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.03
Output  | 2.7512e-05 | 2.7512e-05 | 2.7512e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.10
Other   |            | 0.005241   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191188 ave      191188 max      191188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191188
Ave neighs/atom = 95.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.879886049853, Press = -1.72932986007469
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8433.0831     -8433.0831     -8503.409      -8503.409       272.16836      272.16836      23696.282      23696.282      1568.2893      1568.2893    
     64000  -8437.4654     -8437.4654     -8507.9294     -8507.9294      272.70297      272.70297      23673.244      23673.244      2439.2649      2439.2649    
Loop time of 59.8338 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.444 ns/day, 16.620 hours/ns, 16.713 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    | 59.752     | 59.752     | 59.752     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.02
Output  | 2.7171e-05 | 2.7171e-05 | 2.7171e-05 |   0.0 |  0.00
Modify  | 0.061761   | 0.061761   | 0.061761   |   0.0 |  0.10
Other   |            | 0.005234   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192334 ave      192334 max      192334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192334
Ave neighs/atom = 96.167
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.90768527833, Press = 0.58982319734474
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8437.4654     -8437.4654     -8507.9294     -8507.9294      272.70297      272.70297      23673.244      23673.244      2439.2649      2439.2649    
     65000  -8433.559      -8433.559      -8504.4327     -8504.4327      274.28874      274.28874      23737.991      23737.991     -1685.6737     -1685.6737    
Loop time of 59.8656 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.629 hours/ns, 16.704 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    | 59.784     | 59.784     | 59.784     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.02
Output  | 2.666e-05  | 2.666e-05  | 2.666e-05  |   0.0 |  0.00
Modify  | 0.061773   | 0.061773   | 0.061773   |   0.0 |  0.10
Other   |            | 0.00523    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       193102 ave      193102 max      193102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 193102
Ave neighs/atom = 96.551
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.947297562808, Press = -0.187535940005052
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8433.559      -8433.559      -8504.4327     -8504.4327      274.28874      274.28874      23737.991      23737.991     -1685.6737     -1685.6737    
     66000  -8435.9749     -8435.9749     -8506.8571     -8506.8571      274.3217       274.3217       23713.023      23713.023     -167.969       -167.969      
Loop time of 59.5122 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.452 ns/day, 16.531 hours/ns, 16.803 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    | 59.431     | 59.431     | 59.431     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014831   | 0.014831   | 0.014831   |   0.0 |  0.02
Output  | 2.7451e-05 | 2.7451e-05 | 2.7451e-05 |   0.0 |  0.00
Modify  | 0.061526   | 0.061526   | 0.061526   |   0.0 |  0.10
Other   |            | 0.005232   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191166 ave      191166 max      191166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191166
Ave neighs/atom = 95.583
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936272393535, Press = -0.900325518173358
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8435.9749     -8435.9749     -8506.8571     -8506.8571      274.3217       274.3217       23713.023      23713.023     -167.969       -167.969      
     67000  -8440.1719     -8440.1719     -8509.2299     -8509.2299      267.26168      267.26168      23685.279      23685.279      1234.5771      1234.5771    
Loop time of 59.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.601 hours/ns, 16.732 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    | 59.683     | 59.683     | 59.683     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.02
Output  | 2.7432e-05 | 2.7432e-05 | 2.7432e-05 |   0.0 |  0.00
Modify  | 0.061509   | 0.061509   | 0.061509   |   0.0 |  0.10
Other   |            | 0.005225   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191930 ave      191930 max      191930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191930
Ave neighs/atom = 95.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920392488406, Press = -0.495746330386032
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8440.1719     -8440.1719     -8509.2299     -8509.2299      267.26168      267.26168      23685.279      23685.279      1234.5771      1234.5771    
     68000  -8435.8472     -8435.8472     -8505.9369     -8505.9369      271.25464      271.25464      23721.458      23721.458     -628.41295     -628.41295    
Loop time of 59.6709 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.575 hours/ns, 16.759 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    | 59.589     | 59.589     | 59.589     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.02
Output  | 2.7161e-05 | 2.7161e-05 | 2.7161e-05 |   0.0 |  0.00
Modify  | 0.061568   | 0.061568   | 0.061568   |   0.0 |  0.10
Other   |            | 0.005215   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192428 ave      192428 max      192428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192428
Ave neighs/atom = 96.214
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.893916484812, Press = -0.160455676370014
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8435.8472     -8435.8472     -8505.9369     -8505.9369      271.25464      271.25464      23721.458      23721.458     -628.41295     -628.41295    
     69000  -8437.8617     -8437.8617     -8507.301      -8507.301       268.73718      268.73718      23722.363      23722.363     -1031.2728     -1031.2728    
Loop time of 59.5896 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.450 ns/day, 16.553 hours/ns, 16.781 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    | 59.508     | 59.508     | 59.508     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014881   | 0.014881   | 0.014881   |   0.0 |  0.02
Output  | 2.7422e-05 | 2.7422e-05 | 2.7422e-05 |   0.0 |  0.00
Modify  | 0.06157    | 0.06157    | 0.06157    |   0.0 |  0.10
Other   |            | 0.00522    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191752 ave      191752 max      191752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191752
Ave neighs/atom = 95.876
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874868957633, Press = -1.505943551512
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8437.8617     -8437.8617     -8507.301      -8507.301       268.73718      268.73718      23722.363      23722.363     -1031.2728     -1031.2728    
     70000  -8433.3432     -8433.3432     -8504.6433     -8504.6433      275.93893      275.93893      23667.238      23667.238      3503.2715      3503.2715    
Loop time of 59.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.577 hours/ns, 16.757 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    | 59.596     | 59.596     | 59.596     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014876   | 0.014876   | 0.014876   |   0.0 |  0.02
Output  | 2.7522e-05 | 2.7522e-05 | 2.7522e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.10
Other   |            | 0.005241   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191438 ave      191438 max      191438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191438
Ave neighs/atom = 95.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.907031962153, Press = -0.233687212297496
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8433.3432     -8433.3432     -8504.6433     -8504.6433      275.93893      275.93893      23667.238      23667.238      3503.2715      3503.2715    
     71000  -8438.0502     -8438.0502     -8507.3284     -8507.3284      268.11375      268.11375      23723.01       23723.01      -1078.822      -1078.822     
Loop time of 59.9183 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.442 ns/day, 16.644 hours/ns, 16.689 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    | 59.836     | 59.836     | 59.836     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.02
Output  | 2.7532e-05 | 2.7532e-05 | 2.7532e-05 |   0.0 |  0.00
Modify  | 0.061749   | 0.061749   | 0.061749   |   0.0 |  0.10
Other   |            | 0.005253   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192862 ave      192862 max      192862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192862
Ave neighs/atom = 96.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.921835385562, Press = 0.367052091880093
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8438.0502     -8438.0502     -8507.3284     -8507.3284      268.11375      268.11375      23723.01       23723.01      -1078.822      -1078.822     
     72000  -8437.8126     -8437.8126     -8508.6962     -8508.6962      274.32688      274.32688      23712.79       23712.79      -524.96277     -524.96277    
Loop time of 59.8865 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.443 ns/day, 16.635 hours/ns, 16.698 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    | 59.805     | 59.805     | 59.805     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01495    | 0.01495    | 0.01495    |   0.0 |  0.02
Output  | 2.7121e-05 | 2.7121e-05 | 2.7121e-05 |   0.0 |  0.00
Modify  | 0.061778   | 0.061778   | 0.061778   |   0.0 |  0.10
Other   |            | 0.005228   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191548 ave      191548 max      191548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191548
Ave neighs/atom = 95.774
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.946206209185, Press = -0.908627415107354
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8437.8126     -8437.8126     -8508.6962     -8508.6962      274.32688      274.32688      23712.79       23712.79      -524.96277     -524.96277    
     73000  -8438.3122     -8438.3122     -8508.9171     -8508.9171      273.24822      273.24822      23700.992      23700.992      146.15668      146.15668    
Loop time of 59.7675 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.602 hours/ns, 16.732 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    | 59.686     | 59.686     | 59.686     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014917   | 0.014917   | 0.014917   |   0.0 |  0.02
Output  | 2.7181e-05 | 2.7181e-05 | 2.7181e-05 |   0.0 |  0.00
Modify  | 0.061774   | 0.061774   | 0.061774   |   0.0 |  0.10
Other   |            | 0.005213   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191762 ave      191762 max      191762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191762
Ave neighs/atom = 95.881
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.971795059329, Press = -0.274643011927933
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8438.3122     -8438.3122     -8508.9171     -8508.9171      273.24822      273.24822      23700.992      23700.992      146.15668      146.15668    
     74000  -8433.166      -8433.166      -8504.586      -8504.586       276.40284      276.40284      23724.256      23724.256     -629.2505      -629.2505     
Loop time of 59.7373 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.446 ns/day, 16.594 hours/ns, 16.740 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    | 59.656     | 59.656     | 59.656     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014851   | 0.014851   | 0.014851   |   0.0 |  0.02
Output  | 2.7321e-05 | 2.7321e-05 | 2.7321e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.10
Other   |            | 0.005235   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192058 ave      192058 max      192058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 192058
Ave neighs/atom = 96.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.004366479685, Press = -0.517134051081584
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8433.166      -8433.166      -8504.586      -8504.586       276.40284      276.40284      23724.256      23724.256     -629.2505      -629.2505     
     75000  -8437.6489     -8437.6489     -8508.6944     -8508.6944      274.95342      274.95342      23709.594      23709.594     -316.48876     -316.48876    
Loop time of 59.6922 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.447 ns/day, 16.581 hours/ns, 16.753 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    | 59.61      | 59.61      | 59.61      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014989   | 0.014989   | 0.014989   |   0.0 |  0.03
Output  | 2.67e-05   | 2.67e-05   | 2.67e-05   |   0.0 |  0.00
Modify  | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.10
Other   |            | 0.005219   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       191744 ave      191744 max      191744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 191744
Ave neighs/atom = 95.872
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.016645096904, Press = -0.88571671401397
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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8437.6489     -8437.6489     -8508.6944     -8508.6944      274.95342      274.95342      23709.594      23709.594     -316.48876     -316.48876    
     76000  -8439.0325     -8439.0325     -8507.4977     -8507.4977      264.96761      264.96761      23679.471      23679.471      1817.7742      1817.7742    
Loop time of 59.6803 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.448 ns/day, 16.578 hours/ns, 16.756 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    | 59.598     | 59.598     | 59.598     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01492    | 0.01492    | 0.01492    |   0.0 |  0.03
Output  | 5.9582e-05 | 5.9582e-05 | 5.9582e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.10
Other   |            | 0.005218   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 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:       192022 ave      192022 max      192022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0