# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.031088910996914*${_u_distance}
variable latticeconst_converted equal 3.031088910996914*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891099691
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.000 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoLee_2013_VPdY__MO_046547823135_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_046547823135_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10513.917     -10513.917     -10600         -10600          333.15         333.15         27848.129      27848.129      3301.7221      3301.7221    
      1000  -10419.039     -10419.039     -10513.294     -10513.294      364.77651      364.77651      28027.658      28027.658      2348.3927      2348.3927    
Loop time of 69.2315 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 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    | 69.145     | 69.145     | 69.145     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019798   | 0.019798   | 0.019798   |   0.0 |  0.03
Output  | 0.0001203  | 0.0001203  | 0.0001203  |   0.0 |  0.00
Modify  | 0.060328   | 0.060328   | 0.060328   |   0.0 |  0.09
Other   |            | 0.006226   |            |       |  0.01

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

Total # of neighbors = 336000
Ave neighs/atom = 168
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10419.039     -10419.039     -10513.294     -10513.294      364.77651      364.77651      28027.658      28027.658      2348.3927      2348.3927    
      2000  -10424.62      -10424.62      -10506.748     -10506.748      317.84249      317.84249      28034.466      28034.466      2071.0466      2071.0466    
Loop time of 69.2678 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.437 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    | 69.183     | 69.183     | 69.183     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019549   | 0.019549   | 0.019549   |   0.0 |  0.03
Output  | 5.1227e-05 | 5.1227e-05 | 5.1227e-05 |   0.0 |  0.00
Modify  | 0.059554   | 0.059554   | 0.059554   |   0.0 |  0.09
Other   |            | 0.00602    |            |       |  0.01

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

Total # of neighbors = 324046
Ave neighs/atom = 162.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10424.62      -10424.62      -10506.748     -10506.748      317.84249      317.84249      28034.466      28034.466      2071.0466      2071.0466    
      3000  -10422.723     -10422.723     -10508.993     -10508.993      333.87304      333.87304      28057.55       28057.55       510.32484      510.32484    
Loop time of 69.0906 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.192 hours/ns, 14.474 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    | 69.006     | 69.006     | 69.006     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019368   | 0.019368   | 0.019368   |   0.0 |  0.03
Output  | 4.7119e-05 | 4.7119e-05 | 4.7119e-05 |   0.0 |  0.00
Modify  | 0.059477   | 0.059477   | 0.059477   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 322902
Ave neighs/atom = 161.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10422.723     -10422.723     -10508.993     -10508.993      333.87304      333.87304      28057.55       28057.55       510.32484      510.32484    
      4000  -10422.385     -10422.385     -10511.355     -10511.355      344.32423      344.32423      28061.18       28061.18       850.00051      850.00051    
Loop time of 69.1465 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.462 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    | 69.062     | 69.062     | 69.062     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019363   | 0.019363   | 0.019363   |   0.0 |  0.03
Output  | 5.0786e-05 | 5.0786e-05 | 5.0786e-05 |   0.0 |  0.00
Modify  | 0.059513   | 0.059513   | 0.059513   |   0.0 |  0.09
Other   |            | 0.006008   |            |       |  0.01

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

Total # of neighbors = 322668
Ave neighs/atom = 161.334
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10422.385     -10422.385     -10511.355     -10511.355      344.32423      344.32423      28061.18       28061.18       850.00051      850.00051    
      5000  -10421.429     -10421.429     -10509.801     -10509.801      342.01002      342.01002      28089.009      28089.009     -1149.3638     -1149.3638    
Loop time of 69.4845 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.243 ns/day, 19.301 hours/ns, 14.392 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    | 69.399     | 69.399     | 69.399     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019491   | 0.019491   | 0.019491   |   0.0 |  0.03
Output  | 3.7661e-05 | 3.7661e-05 | 3.7661e-05 |   0.0 |  0.00
Modify  | 0.059723   | 0.059723   | 0.059723   |   0.0 |  0.09
Other   |            | 0.006008   |            |       |  0.01

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

Total # of neighbors = 323574
Ave neighs/atom = 161.787
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 330.89699623911, Press = -1278.18860346155
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10421.429     -10421.429     -10509.801     -10509.801      342.01002      342.01002      28089.009      28089.009     -1149.3638     -1149.3638    
      6000  -10422.951     -10422.951     -10507.778     -10507.778      328.2908       328.2908       28126.211      28126.211     -3099.8578     -3099.8578    
Loop time of 69.2117 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.225 hours/ns, 14.448 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    | 69.124     | 69.124     | 69.124     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019386   | 0.019386   | 0.019386   |   0.0 |  0.03
Output  | 3.9494e-05 | 3.9494e-05 | 3.9494e-05 |   0.0 |  0.00
Modify  | 0.061952   | 0.061952   | 0.061952   |   0.0 |  0.09
Other   |            | 0.006064   |            |       |  0.01

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

Total # of neighbors = 322784
Ave neighs/atom = 161.392
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.199187508845, Press = -113.644999836635
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10422.951     -10422.951     -10507.778     -10507.778      328.2908       328.2908       28126.211      28126.211     -3099.8578     -3099.8578    
      7000  -10422.239     -10422.239     -10506.024     -10506.024      324.25463      324.25463      28112.668      28112.668     -2003.3873     -2003.3873    
Loop time of 69.03 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.252 ns/day, 19.175 hours/ns, 14.486 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.943     | 68.943     | 68.943     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019355   | 0.019355   | 0.019355   |   0.0 |  0.03
Output  | 3.4225e-05 | 3.4225e-05 | 3.4225e-05 |   0.0 |  0.00
Modify  | 0.062005   | 0.062005   | 0.062005   |   0.0 |  0.09
Other   |            | 0.006068   |            |       |  0.01

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

Total # of neighbors = 321650
Ave neighs/atom = 160.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.650246191057, Press = -28.609863558845
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10422.239     -10422.239     -10506.024     -10506.024      324.25463      324.25463      28112.668      28112.668     -2003.3873     -2003.3873    
      8000  -10424.795     -10424.795     -10511.918     -10511.918      337.17504      337.17504      28096.038      28096.038     -1554.114      -1554.114     
Loop time of 69.0789 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.189 hours/ns, 14.476 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.992     | 68.992     | 68.992     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019354   | 0.019354   | 0.019354   |   0.0 |  0.03
Output  | 3.7421e-05 | 3.7421e-05 | 3.7421e-05 |   0.0 |  0.00
Modify  | 0.06189    | 0.06189    | 0.06189    |   0.0 |  0.09
Other   |            | 0.006044   |            |       |  0.01

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

Total # of neighbors = 321770
Ave neighs/atom = 160.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.024630597602, Press = -6.32456881418654
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10424.795     -10424.795     -10511.918     -10511.918      337.17504      337.17504      28096.038      28096.038     -1554.114      -1554.114     
      9000  -10422.396     -10422.396     -10508.623     -10508.623      333.70849      333.70849      28089.308      28089.308     -956.06801     -956.06801    
Loop time of 69.3828 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.273 hours/ns, 14.413 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    | 69.295     | 69.295     | 69.295     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019386   | 0.019386   | 0.019386   |   0.0 |  0.03
Output  | 3.9053e-05 | 3.9053e-05 | 3.9053e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.09
Other   |            | 0.006059   |            |       |  0.01

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

Total # of neighbors = 322908
Ave neighs/atom = 161.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 = 332.218478267238, Press = -2.70820563800377
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10422.396     -10422.396     -10508.623     -10508.623      333.70849      333.70849      28089.308      28089.308     -956.06801     -956.06801    
     10000  -10422.836     -10422.836     -10508.95      -10508.95       333.27019      333.27019      28074.402      28074.402     -13.325964     -13.325964    
Loop time of 69.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.221 hours/ns, 14.452 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    | 69.107     | 69.107     | 69.107     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019413   | 0.019413   | 0.019413   |   0.0 |  0.03
Output  | 3.8072e-05 | 3.8072e-05 | 3.8072e-05 |   0.0 |  0.00
Modify  | 0.061956   | 0.061956   | 0.061956   |   0.0 |  0.09
Other   |            | 0.00605    |            |       |  0.01

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

Total # of neighbors = 322568
Ave neighs/atom = 161.284
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.938880312311, Press = -0.997720295841162
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10422.836     -10422.836     -10508.95      -10508.95       333.27019      333.27019      28074.402      28074.402     -13.325964     -13.325964    
     11000  -10421         -10421         -10507.162     -10507.162      333.45698      333.45698      28057.025      28057.025      929.45435      929.45435    
Loop time of 69.3493 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.264 hours/ns, 14.420 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    | 69.262     | 69.262     | 69.262     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019471   | 0.019471   | 0.019471   |   0.0 |  0.03
Output  | 3.9295e-05 | 3.9295e-05 | 3.9295e-05 |   0.0 |  0.00
Modify  | 0.06187    | 0.06187    | 0.06187    |   0.0 |  0.09
Other   |            | 0.006092   |            |       |  0.01

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

Total # of neighbors = 322876
Ave neighs/atom = 161.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.818215380731, Press = 6.94656449264152
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10421         -10421         -10507.162     -10507.162      333.45698      333.45698      28057.025      28057.025      929.45435      929.45435    
     12000  -10425.621     -10425.621     -10510.41      -10510.41       328.14082      328.14082      28027.604      28027.604      2122.3747      2122.3747    
Loop time of 69.1052 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.196 hours/ns, 14.471 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    | 69.018     | 69.018     | 69.018     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019352   | 0.019352   | 0.019352   |   0.0 |  0.03
Output  | 4.0477e-05 | 4.0477e-05 | 4.0477e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.09
Other   |            | 0.006048   |            |       |  0.01

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

Total # of neighbors = 322808
Ave neighs/atom = 161.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.915540898344, Press = 4.2589493327058
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10425.621     -10425.621     -10510.41      -10510.41       328.14082      328.14082      28027.604      28027.604      2122.3747      2122.3747    
     13000  -10422.224     -10422.224     -10505.538     -10505.538      322.43184      322.43184      28028.228      28028.228      2541.9151      2541.9151    
Loop time of 69.2815 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.245 hours/ns, 14.434 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    | 69.194     | 69.194     | 69.194     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019268   | 0.019268   | 0.019268   |   0.0 |  0.03
Output  | 3.9244e-05 | 3.9244e-05 | 3.9244e-05 |   0.0 |  0.00
Modify  | 0.061919   | 0.061919   | 0.061919   |   0.0 |  0.09
Other   |            | 0.006071   |            |       |  0.01

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

Total # of neighbors = 323592
Ave neighs/atom = 161.796
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.835337493602, Press = 0.226513780392775
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10422.224     -10422.224     -10505.538     -10505.538      322.43184      322.43184      28028.228      28028.228      2541.9151      2541.9151    
     14000  -10420.555     -10420.555     -10509.953     -10509.953      345.97882      345.97882      28038.606      28038.606      1650.9807      1650.9807    
Loop time of 69.3721 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.270 hours/ns, 14.415 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    | 69.285     | 69.285     | 69.285     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019326   | 0.019326   | 0.019326   |   0.0 |  0.03
Output  | 6.6025e-05 | 6.6025e-05 | 6.6025e-05 |   0.0 |  0.00
Modify  | 0.061862   | 0.061862   | 0.061862   |   0.0 |  0.09
Other   |            | 0.006054   |            |       |  0.01

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

Total # of neighbors = 323128
Ave neighs/atom = 161.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.627283790182, Press = -2.37129736453313
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10420.555     -10420.555     -10509.953     -10509.953      345.97882      345.97882      28038.606      28038.606      1650.9807      1650.9807    
     15000  -10420.297     -10420.297     -10507.443     -10507.443      337.2642       337.2642       28041.231      28041.231      1819.7572      1819.7572    
Loop time of 69.3317 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.259 hours/ns, 14.423 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    | 69.244     | 69.244     | 69.244     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01932    | 0.01932    | 0.01932    |   0.0 |  0.03
Output  | 3.3573e-05 | 3.3573e-05 | 3.3573e-05 |   0.0 |  0.00
Modify  | 0.061857   | 0.061857   | 0.061857   |   0.0 |  0.09
Other   |            | 0.006056   |            |       |  0.01

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

Total # of neighbors = 323562
Ave neighs/atom = 161.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.623379979394, Press = -4.64469569798158
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10420.297     -10420.297     -10507.443     -10507.443      337.2642       337.2642       28041.231      28041.231      1819.7572      1819.7572    
     16000  -10426.354     -10426.354     -10509.09      -10509.09       320.19633      320.19633      28035.241      28035.241      1658.8944      1658.8944    
Loop time of 69.3675 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.269 hours/ns, 14.416 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    | 69.28      | 69.28      | 69.28      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01925    | 0.01925    | 0.01925    |   0.0 |  0.03
Output  | 3.5307e-05 | 3.5307e-05 | 3.5307e-05 |   0.0 |  0.00
Modify  | 0.061885   | 0.061885   | 0.061885   |   0.0 |  0.09
Other   |            | 0.006064   |            |       |  0.01

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

Total # of neighbors = 323340
Ave neighs/atom = 161.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.653835970402, Press = -6.14166531436552
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10426.354     -10426.354     -10509.09      -10509.09       320.19633      320.19633      28035.241      28035.241      1658.8944      1658.8944    
     17000  -10421.873     -10421.873     -10506.853     -10506.853      328.88067      328.88067      28048.763      28048.763      1199.1094      1199.1094    
Loop time of 69.2818 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.245 hours/ns, 14.434 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    | 69.195     | 69.195     | 69.195     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019251   | 0.019251   | 0.019251   |   0.0 |  0.03
Output  | 3.4706e-05 | 3.4706e-05 | 3.4706e-05 |   0.0 |  0.00
Modify  | 0.061842   | 0.061842   | 0.061842   |   0.0 |  0.09
Other   |            | 0.006041   |            |       |  0.01

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

Total # of neighbors = 323246
Ave neighs/atom = 161.623
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.586705839957, Press = -9.54033612931329
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10421.873     -10421.873     -10506.853     -10506.853      328.88067      328.88067      28048.763      28048.763      1199.1094      1199.1094    
     18000  -10424.649     -10424.649     -10509.392     -10509.392      327.96393      327.96393      28070.16       28070.16      -102.08977     -102.08977    
Loop time of 69.3046 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.251 hours/ns, 14.429 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    | 69.217     | 69.217     | 69.217     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019296   | 0.019296   | 0.019296   |   0.0 |  0.03
Output  | 3.5847e-05 | 3.5847e-05 | 3.5847e-05 |   0.0 |  0.00
Modify  | 0.06216    | 0.06216    | 0.06216    |   0.0 |  0.09
Other   |            | 0.006069   |            |       |  0.01

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

Total # of neighbors = 322866
Ave neighs/atom = 161.433
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.397240544611, Press = -9.45456710073088
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10424.649     -10424.649     -10509.392     -10509.392      327.96393      327.96393      28070.16       28070.16      -102.08977     -102.08977    
     19000  -10420.757     -10420.757     -10508.106     -10508.106      338.05109      338.05109      28086.358      28086.358     -790.66601     -790.66601    
Loop time of 69.1487 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.462 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    | 69.061     | 69.061     | 69.061     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019301   | 0.019301   | 0.019301   |   0.0 |  0.03
Output  | 3.4906e-05 | 3.4906e-05 | 3.4906e-05 |   0.0 |  0.00
Modify  | 0.062079   | 0.062079   | 0.062079   |   0.0 |  0.09
Other   |            | 0.006055   |            |       |  0.01

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

Total # of neighbors = 323000
Ave neighs/atom = 161.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.43084237033, Press = -5.51188325898363
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10420.757     -10420.757     -10508.106     -10508.106      338.05109      338.05109      28086.358      28086.358     -790.66601     -790.66601    
     20000  -10423.513     -10423.513     -10507.394     -10507.394      324.62877      324.62877      28084.748      28084.748     -795.7408      -795.7408     
Loop time of 69.3585 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.266 hours/ns, 14.418 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    | 69.271     | 69.271     | 69.271     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019271   | 0.019271   | 0.019271   |   0.0 |  0.03
Output  | 2.8604e-05 | 2.8604e-05 | 2.8604e-05 |   0.0 |  0.00
Modify  | 0.062083   | 0.062083   | 0.062083   |   0.0 |  0.09
Other   |            | 0.006068   |            |       |  0.01

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

Total # of neighbors = 322610
Ave neighs/atom = 161.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 = 332.543038293475, Press = -3.97503250056071
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10423.513     -10423.513     -10507.394     -10507.394      324.62877      324.62877      28084.748      28084.748     -795.7408      -795.7408     
     21000  -10427.596     -10427.596     -10510.178     -10510.178      319.60135      319.60135      28082.641      28082.641     -1029.106      -1029.106     
Loop time of 69.2149 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.226 hours/ns, 14.448 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    | 69.127     | 69.127     | 69.127     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019357   | 0.019357   | 0.019357   |   0.0 |  0.03
Output  | 3.3734e-05 | 3.3734e-05 | 3.3734e-05 |   0.0 |  0.00
Modify  | 0.062113   | 0.062113   | 0.062113   |   0.0 |  0.09
Other   |            | 0.006051   |            |       |  0.01

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

Total # of neighbors = 322534
Ave neighs/atom = 161.267
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.604449894403, Press = -3.36125913665018
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10427.596     -10427.596     -10510.178     -10510.178      319.60135      319.60135      28082.641      28082.641     -1029.106      -1029.106     
     22000  -10421.522     -10421.522     -10508.692     -10508.692      337.35826      337.35826      28110.369      28110.369     -2209.4279     -2209.4279    
Loop time of 69.1582 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.211 hours/ns, 14.460 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    | 69.071     | 69.071     | 69.071     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019247   | 0.019247   | 0.019247   |   0.0 |  0.03
Output  | 3.2281e-05 | 3.2281e-05 | 3.2281e-05 |   0.0 |  0.00
Modify  | 0.061865   | 0.061865   | 0.061865   |   0.0 |  0.09
Other   |            | 0.006031   |            |       |  0.01

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

Total # of neighbors = 322532
Ave neighs/atom = 161.266
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.461839044221, Press = -3.00888321593078
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10421.522     -10421.522     -10508.692     -10508.692      337.35826      337.35826      28110.369      28110.369     -2209.4279     -2209.4279    
     23000  -10424.264     -10424.264     -10509.162     -10509.162      328.56761      328.56761      28135.835      28135.835     -3779.4358     -3779.4358    
Loop time of 69.1074 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.197 hours/ns, 14.470 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    | 69.02      | 69.02      | 69.02      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01924    | 0.01924    | 0.01924    |   0.0 |  0.03
Output  | 3.3594e-05 | 3.3594e-05 | 3.3594e-05 |   0.0 |  0.00
Modify  | 0.06186    | 0.06186    | 0.06186    |   0.0 |  0.09
Other   |            | 0.006016   |            |       |  0.01

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

Total # of neighbors = 322328
Ave neighs/atom = 161.164
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.452321884473, Press = -0.699510090634528
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10424.264     -10424.264     -10509.162     -10509.162      328.56761      328.56761      28135.835      28135.835     -3779.4358     -3779.4358    
     24000  -10418.588     -10418.588     -10505.713     -10505.713      337.18465      337.18465      28110.941      28110.941     -1795.5388     -1795.5388    
Loop time of 69.086 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.191 hours/ns, 14.475 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    | 68.999     | 68.999     | 68.999     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019202   | 0.019202   | 0.019202   |   0.0 |  0.03
Output  | 3.2251e-05 | 3.2251e-05 | 3.2251e-05 |   0.0 |  0.00
Modify  | 0.061935   | 0.061935   | 0.061935   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 321958
Ave neighs/atom = 160.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.609939671986, Press = 0.72872990577454
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10418.588     -10418.588     -10505.713     -10505.713      337.18465      337.18465      28110.941      28110.941     -1795.5388     -1795.5388    
     25000  -10424.15      -10424.15      -10508.198     -10508.198      325.27343      325.27343      28078.588      28078.588     -478.99908     -478.99908    
Loop time of 69.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.182 hours/ns, 14.481 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    | 68.968     | 68.968     | 68.968     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01926    | 0.01926    | 0.01926    |   0.0 |  0.03
Output  | 3.0417e-05 | 3.0417e-05 | 3.0417e-05 |   0.0 |  0.00
Modify  | 0.061817   | 0.061817   | 0.061817   |   0.0 |  0.09
Other   |            | 0.006022   |            |       |  0.01

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

Total # of neighbors = 322086
Ave neighs/atom = 161.043
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.688200338173, Press = 0.290585499348172
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10424.15      -10424.15      -10508.198     -10508.198      325.27343      325.27343      28078.588      28078.588     -478.99908     -478.99908    
     26000  -10422.407     -10422.407     -10507.14      -10507.14       327.92686      327.92686      28066.674      28066.674      267.7677       267.7677     
Loop time of 69.1358 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.204 hours/ns, 14.464 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    | 69.049     | 69.049     | 69.049     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019316   | 0.019316   | 0.019316   |   0.0 |  0.03
Output  | 3.0447e-05 | 3.0447e-05 | 3.0447e-05 |   0.0 |  0.00
Modify  | 0.061852   | 0.061852   | 0.061852   |   0.0 |  0.09
Other   |            | 0.00602    |            |       |  0.01

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

Total # of neighbors = 322578
Ave neighs/atom = 161.289
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.634644192115, Press = -0.112943348553221
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10422.407     -10422.407     -10507.14      -10507.14       327.92686      327.92686      28066.674      28066.674      267.7677       267.7677     
     27000  -10423.941     -10423.941     -10509.815     -10509.815      332.33936      332.33936      28054.389      28054.389      873.57887      873.57887    
Loop time of 69.4214 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.284 hours/ns, 14.405 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    | 69.334     | 69.334     | 69.334     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019141   | 0.019141   | 0.019141   |   0.0 |  0.03
Output  | 2.9516e-05 | 2.9516e-05 | 2.9516e-05 |   0.0 |  0.00
Modify  | 0.061793   | 0.061793   | 0.061793   |   0.0 |  0.09
Other   |            | 0.006051   |            |       |  0.01

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

Total # of neighbors = 322992
Ave neighs/atom = 161.496
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.598725472667, Press = -0.602492204225905
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10423.941     -10423.941     -10509.815     -10509.815      332.33936      332.33936      28054.389      28054.389      873.57887      873.57887    
     28000  -10420.989     -10420.989     -10507.102     -10507.102      333.26664      333.26664      28024.83       28024.83       2679.09        2679.09      
Loop time of 69.2356 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.232 hours/ns, 14.443 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    | 69.149     | 69.149     | 69.149     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019232   | 0.019232   | 0.019232   |   0.0 |  0.03
Output  | 2.9466e-05 | 2.9466e-05 | 2.9466e-05 |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322954
Ave neighs/atom = 161.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 = 332.622491621038, Press = 0.170562799676882
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10420.989     -10420.989     -10507.102     -10507.102      333.26664      333.26664      28024.83       28024.83       2679.09        2679.09      
     29000  -10422.316     -10422.316     -10510.082     -10510.082      339.66334      339.66334      27999.062      27999.062      3905.9001      3905.9001    
Loop time of 69.3354 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.260 hours/ns, 14.423 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    | 69.248     | 69.248     | 69.248     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019197   | 0.019197   | 0.019197   |   0.0 |  0.03
Output  | 3.2953e-05 | 3.2953e-05 | 3.2953e-05 |   0.0 |  0.00
Modify  | 0.061762   | 0.061762   | 0.061762   |   0.0 |  0.09
Other   |            | 0.006027   |            |       |  0.01

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

Total # of neighbors = 323462
Ave neighs/atom = 161.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.762752047966, Press = -1.04803387163249
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10422.316     -10422.316     -10510.082     -10510.082      339.66334      339.66334      27999.062      27999.062      3905.9001      3905.9001    
     30000  -10422.568     -10422.568     -10509.977     -10509.977      338.28487      338.28487      28039.511      28039.511      1666.6769      1666.6769    
Loop time of 69.5005 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.243 ns/day, 19.306 hours/ns, 14.388 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    | 69.413     | 69.413     | 69.413     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019193   | 0.019193   | 0.019193   |   0.0 |  0.03
Output  | 2.9986e-05 | 2.9986e-05 | 2.9986e-05 |   0.0 |  0.00
Modify  | 0.061815   | 0.061815   | 0.061815   |   0.0 |  0.09
Other   |            | 0.006052   |            |       |  0.01

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

Total # of neighbors = 323898
Ave neighs/atom = 161.949
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.788180695277, Press = -2.08460745859772
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10422.568     -10422.568     -10509.977     -10509.977      338.28487      338.28487      28039.511      28039.511      1666.6769      1666.6769    
     31000  -10419.197     -10419.197     -10505.202     -10505.202      332.84997      332.84997      28060.067      28060.067      1093.9858      1093.9858    
Loop time of 69.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.265 hours/ns, 14.419 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    | 69.268     | 69.268     | 69.268     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01922    | 0.01922    | 0.01922    |   0.0 |  0.03
Output  | 3.0387e-05 | 3.0387e-05 | 3.0387e-05 |   0.0 |  0.00
Modify  | 0.061882   | 0.061882   | 0.061882   |   0.0 |  0.09
Other   |            | 0.006033   |            |       |  0.01

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

Total # of neighbors = 323476
Ave neighs/atom = 161.738
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.931187533385, Press = -2.4825764481223
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10419.197     -10419.197     -10505.202     -10505.202      332.84997      332.84997      28060.067      28060.067      1093.9858      1093.9858    
     32000  -10425.267     -10425.267     -10510.026     -10510.026      328.02481      328.02481      28059.859      28059.859      360.36162      360.36162    
Loop time of 69.4095 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.280 hours/ns, 14.407 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    | 69.322     | 69.322     | 69.322     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01923    | 0.01923    | 0.01923    |   0.0 |  0.03
Output  | 3.0558e-05 | 3.0558e-05 | 3.0558e-05 |   0.0 |  0.00
Modify  | 0.061825   | 0.061825   | 0.061825   |   0.0 |  0.09
Other   |            | 0.006046   |            |       |  0.01

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

Total # of neighbors = 322962
Ave neighs/atom = 161.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.936558187344, Press = -2.94871598636581
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10425.267     -10425.267     -10510.026     -10510.026      328.02481      328.02481      28059.859      28059.859      360.36162      360.36162    
     33000  -10420.611     -10420.611     -10506.522     -10506.522      332.48435      332.48435      28084.138      28084.138     -540.65701     -540.65701    
Loop time of 69.2803 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.245 hours/ns, 14.434 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    | 69.193     | 69.193     | 69.193     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01916    | 0.01916    | 0.01916    |   0.0 |  0.03
Output  | 3.1229e-05 | 3.1229e-05 | 3.1229e-05 |   0.0 |  0.00
Modify  | 0.061755   | 0.061755   | 0.061755   |   0.0 |  0.09
Other   |            | 0.00601    |            |       |  0.01

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

Total # of neighbors = 323076
Ave neighs/atom = 161.538
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.934687043454, Press = -3.397445004886
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10420.611     -10420.611     -10506.522     -10506.522      332.48435      332.48435      28084.138      28084.138     -540.65701     -540.65701    
     34000  -10426.077     -10426.077     -10509.651     -10509.651      323.437        323.437        28124.5        28124.5       -3127.2546     -3127.2546    
Loop time of 69.4051 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.279 hours/ns, 14.408 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    | 69.318     | 69.318     | 69.318     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019135   | 0.019135   | 0.019135   |   0.0 |  0.03
Output  | 3.0007e-05 | 3.0007e-05 | 3.0007e-05 |   0.0 |  0.00
Modify  | 0.061765   | 0.061765   | 0.061765   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 322636
Ave neighs/atom = 161.318
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.864750777635, Press = -5.37971768707338
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10426.077     -10426.077     -10509.651     -10509.651      323.437        323.437        28124.5        28124.5       -3127.2546     -3127.2546    
     35000  -10421.389     -10421.389     -10508.295     -10508.295      336.3336       336.3336       28131.63       28131.63      -3081.3549     -3081.3549    
Loop time of 69.1056 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.196 hours/ns, 14.471 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    | 69.019     | 69.019     | 69.019     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019187   | 0.019187   | 0.019187   |   0.0 |  0.03
Output  | 3.0568e-05 | 3.0568e-05 | 3.0568e-05 |   0.0 |  0.00
Modify  | 0.061752   | 0.061752   | 0.061752   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 321964
Ave neighs/atom = 160.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.822208835947, Press = -2.4370871255468
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10421.389     -10421.389     -10508.295     -10508.295      336.3336       336.3336       28131.63       28131.63      -3081.3549     -3081.3549    
     36000  -10425.535     -10425.535     -10510.005     -10510.005      326.90732      326.90732      28104.736      28104.736     -2025.7345     -2025.7345    
Loop time of 69.1746 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.215 hours/ns, 14.456 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    | 69.087     | 69.087     | 69.087     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019278   | 0.019278   | 0.019278   |   0.0 |  0.03
Output  | 3.0928e-05 | 3.0928e-05 | 3.0928e-05 |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.09
Other   |            | 0.006044   |            |       |  0.01

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

Total # of neighbors = 321906
Ave neighs/atom = 160.953
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.801800432797, Press = -0.667987844232292
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10425.535     -10425.535     -10510.005     -10510.005      326.90732      326.90732      28104.736      28104.736     -2025.7345     -2025.7345    
     37000  -10421.523     -10421.523     -10509.387     -10509.387      340.04629      340.04629      28099.855      28099.855     -1622.2992     -1622.2992    
Loop time of 69.2566 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.238 hours/ns, 14.439 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    | 69.169     | 69.169     | 69.169     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019316   | 0.019316   | 0.019316   |   0.0 |  0.03
Output  | 3.0808e-05 | 3.0808e-05 | 3.0808e-05 |   0.0 |  0.00
Modify  | 0.061834   | 0.061834   | 0.061834   |   0.0 |  0.09
Other   |            | 0.006069   |            |       |  0.01

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

Total # of neighbors = 322716
Ave neighs/atom = 161.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.780644187873, Press = -0.07752066821665
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10421.523     -10421.523     -10509.387     -10509.387      340.04629      340.04629      28099.855      28099.855     -1622.2992     -1622.2992    
     38000  -10427.917     -10427.917     -10512.412     -10512.412      327.00539      327.00539      28082.124      28082.124     -971.73835     -971.73835    
Loop time of 69.1706 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.214 hours/ns, 14.457 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    | 69.083     | 69.083     | 69.083     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019336   | 0.019336   | 0.019336   |   0.0 |  0.03
Output  | 3.0037e-05 | 3.0037e-05 | 3.0037e-05 |   0.0 |  0.00
Modify  | 0.061779   | 0.061779   | 0.061779   |   0.0 |  0.09
Other   |            | 0.006045   |            |       |  0.01

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

Total # of neighbors = 322328
Ave neighs/atom = 161.164
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.69357176704, Press = 0.0556496709001343
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10427.917     -10427.917     -10512.412     -10512.412      327.00539      327.00539      28082.124      28082.124     -971.73835     -971.73835    
     39000  -10423.313     -10423.313     -10509.06      -10509.06       331.85176      331.85176      28086.605      28086.605     -886.54532     -886.54532    
Loop time of 69.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.199 hours/ns, 14.469 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    | 69.028     | 69.028     | 69.028     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01925    | 0.01925    | 0.01925    |   0.0 |  0.03
Output  | 3.0758e-05 | 3.0758e-05 | 3.0758e-05 |   0.0 |  0.00
Modify  | 0.061734   | 0.061734   | 0.061734   |   0.0 |  0.09
Other   |            | 0.006034   |            |       |  0.01

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

Total # of neighbors = 323160
Ave neighs/atom = 161.58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.719669400865, Press = 0.211883270810159
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10423.313     -10423.313     -10509.06      -10509.06       331.85176      331.85176      28086.605      28086.605     -886.54532     -886.54532    
     40000  -10420.009     -10420.009     -10506.5       -10506.5        334.7311       334.7311       28083.636      28083.636     -511.44934     -511.44934    
Loop time of 69.1801 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.217 hours/ns, 14.455 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    | 69.093     | 69.093     | 69.093     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019236   | 0.019236   | 0.019236   |   0.0 |  0.03
Output  | 2.9716e-05 | 2.9716e-05 | 2.9716e-05 |   0.0 |  0.00
Modify  | 0.061831   | 0.061831   | 0.061831   |   0.0 |  0.09
Other   |            | 0.006035   |            |       |  0.01

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

Total # of neighbors = 322766
Ave neighs/atom = 161.383
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.743203601753, Press = 1.8438555621617
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10420.009     -10420.009     -10506.5       -10506.5        334.7311       334.7311       28083.636      28083.636     -511.44934     -511.44934    
     41000  -10426.637     -10426.637     -10513.149     -10513.149      334.80728      334.80728      28041.469      28041.469      1023.2241      1023.2241    
Loop time of 69.3114 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.253 hours/ns, 14.428 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    | 69.224     | 69.224     | 69.224     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019362   | 0.019362   | 0.019362   |   0.0 |  0.03
Output  | 2.9385e-05 | 2.9385e-05 | 2.9385e-05 |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.09
Other   |            | 0.006044   |            |       |  0.01

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

Total # of neighbors = 322596
Ave neighs/atom = 161.298
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.68692488522, Press = 2.1052361185106
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10426.637     -10426.637     -10513.149     -10513.149      334.80728      334.80728      28041.469      28041.469      1023.2241      1023.2241    
     42000  -10419.624     -10419.624     -10508.471     -10508.471      343.84564      343.84564      28049.614      28049.614      1064.9181      1064.9181    
Loop time of 69.3425 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.262 hours/ns, 14.421 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    | 69.255     | 69.255     | 69.255     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01926    | 0.01926    | 0.01926    |   0.0 |  0.03
Output  | 2.9646e-05 | 2.9646e-05 | 2.9646e-05 |   0.0 |  0.00
Modify  | 0.061798   | 0.061798   | 0.061798   |   0.0 |  0.09
Other   |            | 0.006038   |            |       |  0.01

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

Total # of neighbors = 323892
Ave neighs/atom = 161.946
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.68532485635, Press = 0.131808452606086
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10419.624     -10419.624     -10508.471     -10508.471      343.84564      343.84564      28049.614      28049.614      1064.9181      1064.9181    
     43000  -10423.864     -10423.864     -10510.018     -10510.018      333.42377      333.42377      28045.724      28045.724      880.52283      880.52283    
Loop time of 69.2754 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.243 hours/ns, 14.435 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    | 69.188     | 69.188     | 69.188     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019232   | 0.019232   | 0.019232   |   0.0 |  0.03
Output  | 2.9666e-05 | 2.9666e-05 | 2.9666e-05 |   0.0 |  0.00
Modify  | 0.06179    | 0.06179    | 0.06179    |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 322938
Ave neighs/atom = 161.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.759684902207, Press = -0.582228073238636
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10423.864     -10423.864     -10510.018     -10510.018      333.42377      333.42377      28045.724      28045.724      880.52283      880.52283    
     44000  -10421.241     -10421.241     -10508.432     -10508.432      337.43874      337.43874      28049.562      28049.562      927.03903      927.03903    
Loop time of 69.3405 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.261 hours/ns, 14.422 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    | 69.253     | 69.253     | 69.253     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019255   | 0.019255   | 0.019255   |   0.0 |  0.03
Output  | 2.9626e-05 | 2.9626e-05 | 2.9626e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.09
Other   |            | 0.006036   |            |       |  0.01

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

Total # of neighbors = 323212
Ave neighs/atom = 161.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.790098379956, Press = -1.14092773971977
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10421.241     -10421.241     -10508.432     -10508.432      337.43874      337.43874      28049.562      28049.562      927.03903      927.03903    
     45000  -10424.702     -10424.702     -10509.763     -10509.763      329.19315      329.19315      28045.405      28045.405      1193.0691      1193.0691    
Loop time of 69.2598 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.239 hours/ns, 14.438 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    | 69.173     | 69.173     | 69.173     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019243   | 0.019243   | 0.019243   |   0.0 |  0.03
Output  | 3.0248e-05 | 3.0248e-05 | 3.0248e-05 |   0.0 |  0.00
Modify  | 0.061761   | 0.061761   | 0.061761   |   0.0 |  0.09
Other   |            | 0.00603    |            |       |  0.01

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

Total # of neighbors = 323262
Ave neighs/atom = 161.631
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.774696774316, Press = -1.76744638919625
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10424.702     -10424.702     -10509.763     -10509.763      329.19315      329.19315      28045.405      28045.405      1193.0691      1193.0691    
     46000  -10418.986     -10418.986     -10507.591     -10507.591      342.90938      342.90938      28069.752      28069.752      192.66005      192.66005    
Loop time of 69.3115 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.253 hours/ns, 14.428 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    | 69.224     | 69.224     | 69.224     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019277   | 0.019277   | 0.019277   |   0.0 |  0.03
Output  | 3.3133e-05 | 3.3133e-05 | 3.3133e-05 |   0.0 |  0.00
Modify  | 0.061821   | 0.061821   | 0.061821   |   0.0 |  0.09
Other   |            | 0.006037   |            |       |  0.01

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

Total # of neighbors = 323462
Ave neighs/atom = 161.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.76595223451, Press = -2.54098065845008
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10418.986     -10418.986     -10507.591     -10507.591      342.90938      342.90938      28069.752      28069.752      192.66005      192.66005    
     47000  -10423.466     -10423.466     -10508.786     -10508.786      330.19865      330.19865      28091.024      28091.024     -1222.012      -1222.012     
Loop time of 69.1293 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.203 hours/ns, 14.466 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    | 69.042     | 69.042     | 69.042     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019193   | 0.019193   | 0.019193   |   0.0 |  0.03
Output  | 2.9335e-05 | 2.9335e-05 | 2.9335e-05 |   0.0 |  0.00
Modify  | 0.061823   | 0.061823   | 0.061823   |   0.0 |  0.09
Other   |            | 0.006046   |            |       |  0.01

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

Total # of neighbors = 322622
Ave neighs/atom = 161.311
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.795271367258, Press = -2.8949733055807
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10423.466     -10423.466     -10508.786     -10508.786      330.19865      330.19865      28091.024      28091.024     -1222.012      -1222.012     
     48000  -10419.679     -10419.679     -10507.554     -10507.554      340.08756      340.08756      28108.472      28108.472     -1914.9787     -1914.9787    
Loop time of 69.2281 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.230 hours/ns, 14.445 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    | 69.141     | 69.141     | 69.141     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019276   | 0.019276   | 0.019276   |   0.0 |  0.03
Output  | 3.0407e-05 | 3.0407e-05 | 3.0407e-05 |   0.0 |  0.00
Modify  | 0.061709   | 0.061709   | 0.061709   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322470
Ave neighs/atom = 161.235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867085753754, Press = -1.91302005227834
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10419.679     -10419.679     -10507.554     -10507.554      340.08756      340.08756      28108.472      28108.472     -1914.9787     -1914.9787    
     49000  -10423.433     -10423.433     -10508.86      -10508.86       330.61206      330.61206      28089.194      28089.194     -1272.7788     -1272.7788    
Loop time of 69.1761 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.216 hours/ns, 14.456 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    | 69.089     | 69.089     | 69.089     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019169   | 0.019169   | 0.019169   |   0.0 |  0.03
Output  | 2.9115e-05 | 2.9115e-05 | 2.9115e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.09
Other   |            | 0.006022   |            |       |  0.01

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

Total # of neighbors = 322262
Ave neighs/atom = 161.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863176262021, Press = -0.884602485992033
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10423.433     -10423.433     -10508.86      -10508.86       330.61206      330.61206      28089.194      28089.194     -1272.7788     -1272.7788    
     50000  -10420.267     -10420.267     -10507.046     -10507.046      335.84514      335.84514      28094.187      28094.187     -1304.2171     -1304.2171    
Loop time of 69.0772 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.188 hours/ns, 14.477 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    | 68.99      | 68.99      | 68.99      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019163   | 0.019163   | 0.019163   |   0.0 |  0.03
Output  | 3.3283e-05 | 3.3283e-05 | 3.3283e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.09
Other   |            | 0.005994   |            |       |  0.01

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

Total # of neighbors = 322542
Ave neighs/atom = 161.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.877940043113, Press = -0.49876983395477
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10420.267     -10420.267     -10507.046     -10507.046      335.84514      335.84514      28094.187      28094.187     -1304.2171     -1304.2171    
     51000  -10423.836     -10423.836     -10508.616     -10508.616      328.11055      328.11055      28081.238      28081.238     -824.04116     -824.04116    
Loop time of 69.1044 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.196 hours/ns, 14.471 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    | 69.017     | 69.017     | 69.017     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019202   | 0.019202   | 0.019202   |   0.0 |  0.03
Output  | 3.0838e-05 | 3.0838e-05 | 3.0838e-05 |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.09
Other   |            | 0.006019   |            |       |  0.01

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

Total # of neighbors = 322422
Ave neighs/atom = 161.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 = 332.849075766608, Press = -0.311199120669689
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10423.836     -10423.836     -10508.616     -10508.616      328.11055      328.11055      28081.238      28081.238     -824.04116     -824.04116    
     52000  -10422.061     -10422.061     -10507.257     -10507.257      329.71563      329.71563      28090.099      28090.099     -1092.5315     -1092.5315    
Loop time of 69.3387 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.261 hours/ns, 14.422 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    | 69.252     | 69.252     | 69.252     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019182   | 0.019182   | 0.019182   |   0.0 |  0.03
Output  | 6.1756e-05 | 6.1756e-05 | 6.1756e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.09
Other   |            | 0.006013   |            |       |  0.01

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

Total # of neighbors = 322520
Ave neighs/atom = 161.26
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.837423394471, Press = 0.405419283172023
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10422.061     -10422.061     -10507.257     -10507.257      329.71563      329.71563      28090.099      28090.099     -1092.5315     -1092.5315    
     53000  -10423.855     -10423.855     -10509.878     -10509.878      332.91968      332.91968      28076.034      28076.034     -457.8472      -457.8472     
Loop time of 69.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.244 hours/ns, 14.435 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    | 69.191     | 69.191     | 69.191     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019261   | 0.019261   | 0.019261   |   0.0 |  0.03
Output  | 3.0267e-05 | 3.0267e-05 | 3.0267e-05 |   0.0 |  0.00
Modify  | 0.061791   | 0.061791   | 0.061791   |   0.0 |  0.09
Other   |            | 0.006009   |            |       |  0.01

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

Total # of neighbors = 322524
Ave neighs/atom = 161.262
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.875500418865, Press = 1.51878838967126
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10423.855     -10423.855     -10509.878     -10509.878      332.91968      332.91968      28076.034      28076.034     -457.8472      -457.8472     
     54000  -10425.229     -10425.229     -10510.086     -10510.086      328.40819      328.40819      28055.597      28055.597      641.46004      641.46004    
Loop time of 69.3645 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.268 hours/ns, 14.417 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    | 69.277     | 69.277     | 69.277     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019323   | 0.019323   | 0.019323   |   0.0 |  0.03
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 323194
Ave neighs/atom = 161.597
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.908262479676, Press = 0.926586193613652
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10425.229     -10425.229     -10510.086     -10510.086      328.40819      328.40819      28055.597      28055.597      641.46004      641.46004    
     55000  -10423.817     -10423.817     -10509.048     -10509.048      329.85445      329.85445      28044.868      28044.868      1274.3905      1274.3905    
Loop time of 69.2273 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.230 hours/ns, 14.445 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    | 69.14      | 69.14      | 69.14      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019283   | 0.019283   | 0.019283   |   0.0 |  0.03
Output  | 2.9185e-05 | 2.9185e-05 | 2.9185e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.09
Other   |            | 0.006004   |            |       |  0.01

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

Total # of neighbors = 323222
Ave neighs/atom = 161.611
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.854590918779, Press = 0.296829506361929
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10423.817     -10423.817     -10509.048     -10509.048      329.85445      329.85445      28044.868      28044.868      1274.3905      1274.3905    
     56000  -10423.897     -10423.897     -10510.965     -10510.965      336.96568      336.96568      28049.593      28049.593      969.58345      969.58345    
Loop time of 69.2451 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.235 hours/ns, 14.441 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    | 69.158     | 69.158     | 69.158     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019287   | 0.019287   | 0.019287   |   0.0 |  0.03
Output  | 3.0708e-05 | 3.0708e-05 | 3.0708e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.09
Other   |            | 0.006013   |            |       |  0.01

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

Total # of neighbors = 323310
Ave neighs/atom = 161.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.853725134997, Press = -0.182733228094341
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10423.897     -10423.897     -10510.965     -10510.965      336.96568      336.96568      28049.593      28049.593      969.58345      969.58345    
     57000  -10418.905     -10418.905     -10506.983     -10506.983      340.87091      340.87091      28068.979      28068.979      335.94662      335.94662    
Loop time of 69.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.248 hours/ns, 14.432 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    | 69.205     | 69.205     | 69.205     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019234   | 0.019234   | 0.019234   |   0.0 |  0.03
Output  | 2.9606e-05 | 2.9606e-05 | 2.9606e-05 |   0.0 |  0.00
Modify  | 0.061759   | 0.061759   | 0.061759   |   0.0 |  0.09
Other   |            | 0.006007   |            |       |  0.01

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

Total # of neighbors = 323160
Ave neighs/atom = 161.58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876774353527, Press = -0.465007877556406
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10418.905     -10418.905     -10506.983     -10506.983      340.87091      340.87091      28068.979      28068.979      335.94662      335.94662    
     58000  -10423.31      -10423.31      -10511.309     -10511.309      340.56487      340.56487      28064.714      28064.714     -16.408075     -16.408075    
Loop time of 69.0966 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.193 hours/ns, 14.472 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    | 69.009     | 69.009     | 69.009     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019273   | 0.019273   | 0.019273   |   0.0 |  0.03
Output  | 3.0217e-05 | 3.0217e-05 | 3.0217e-05 |   0.0 |  0.00
Modify  | 0.061789   | 0.061789   | 0.061789   |   0.0 |  0.09
Other   |            | 0.005998   |            |       |  0.01

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

Total # of neighbors = 322854
Ave neighs/atom = 161.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905136312783, Press = -0.470382988979325
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10423.31      -10423.31      -10511.309     -10511.309      340.56487      340.56487      28064.714      28064.714     -16.408075     -16.408075    
     59000  -10421.911     -10421.911     -10507.715     -10507.715      332.06941      332.06941      28061.309      28061.309      582.10997      582.10997    
Loop time of 69.2323 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 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    | 69.145     | 69.145     | 69.145     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019275   | 0.019275   | 0.019275   |   0.0 |  0.03
Output  | 3.2682e-05 | 3.2682e-05 | 3.2682e-05 |   0.0 |  0.00
Modify  | 0.061839   | 0.061839   | 0.061839   |   0.0 |  0.09
Other   |            | 0.00602    |            |       |  0.01

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

Total # of neighbors = 323266
Ave neighs/atom = 161.633
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907167847625, Press = -0.569173567409858
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10421.911     -10421.911     -10507.715     -10507.715      332.06941      332.06941      28061.309      28061.309      582.10997      582.10997    
     60000  -10426.454     -10426.454     -10510.54      -10510.54       325.41784      325.41784      28050.846      28050.846      631.92468      631.92468    
Loop time of 69.1663 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.213 hours/ns, 14.458 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    | 69.079     | 69.079     | 69.079     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019232   | 0.019232   | 0.019232   |   0.0 |  0.03
Output  | 2.8765e-05 | 2.8765e-05 | 2.8765e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 322956
Ave neighs/atom = 161.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.889443551519, Press = -0.74943793624318
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10426.454     -10426.454     -10510.54      -10510.54       325.41784      325.41784      28050.846      28050.846      631.92468      631.92468    
     61000  -10422.047     -10422.047     -10506.547     -10506.547      327.02453      327.02453      28051.989      28051.989      1248.6131      1248.6131    
Loop time of 69.2202 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.228 hours/ns, 14.447 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    | 69.133     | 69.133     | 69.133     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019246   | 0.019246   | 0.019246   |   0.0 |  0.03
Output  | 3.213e-05  | 3.213e-05  | 3.213e-05  |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.09
Other   |            | 0.006031   |            |       |  0.01

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

Total # of neighbors = 323308
Ave neighs/atom = 161.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.837636949052, Press = -0.854397880685975
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10422.047     -10422.047     -10506.547     -10506.547      327.02453      327.02453      28051.989      28051.989      1248.6131      1248.6131    
     62000  -10421.336     -10421.336     -10506.768     -10506.768      330.6316       330.6316       28063.002      28063.002      511.29619      511.29619    
Loop time of 69.1247 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.201 hours/ns, 14.467 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    | 69.038     | 69.038     | 69.038     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019275   | 0.019275   | 0.019275   |   0.0 |  0.03
Output  | 3.0638e-05 | 3.0638e-05 | 3.0638e-05 |   0.0 |  0.00
Modify  | 0.061814   | 0.061814   | 0.061814   |   0.0 |  0.09
Other   |            | 0.00602    |            |       |  0.01

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

Total # of neighbors = 323100
Ave neighs/atom = 161.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.843296118602, Press = -1.45984194741956
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10421.336     -10421.336     -10506.768     -10506.768      330.6316       330.6316       28063.002      28063.002      511.29619      511.29619    
     63000  -10423.839     -10423.839     -10507.598     -10507.598      324.15499      324.15499      28069.627      28069.627      9.8216366      9.8216366    
Loop time of 69.2693 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.436 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    | 69.182     | 69.182     | 69.182     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019225   | 0.019225   | 0.019225   |   0.0 |  0.03
Output  | 3.2842e-05 | 3.2842e-05 | 3.2842e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.09
Other   |            | 0.006018   |            |       |  0.01

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

Total # of neighbors = 322718
Ave neighs/atom = 161.359
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.798398214199, Press = -1.69331658299129
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10423.839     -10423.839     -10507.598     -10507.598      324.15499      324.15499      28069.627      28069.627      9.8216366      9.8216366    
     64000  -10423.251     -10423.251     -10507.19      -10507.19       324.85403      324.85403      28090.023      28090.023     -1091.1121     -1091.1121    
Loop time of 69.3452 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.263 hours/ns, 14.421 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    | 69.258     | 69.258     | 69.258     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019211   | 0.019211   | 0.019211   |   0.0 |  0.03
Output  | 3.2111e-05 | 3.2111e-05 | 3.2111e-05 |   0.0 |  0.00
Modify  | 0.061684   | 0.061684   | 0.061684   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322916
Ave neighs/atom = 161.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.794282180559, Press = -1.67212505883437
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10423.251     -10423.251     -10507.19      -10507.19       324.85403      324.85403      28090.023      28090.023     -1091.1121     -1091.1121    
     65000  -10422.09      -10422.09      -10507.003     -10507.003      328.62136      328.62136      28104.711      28104.711     -1748.3831     -1748.3831    
Loop time of 69.0869 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.191 hours/ns, 14.475 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    | 69         | 69         | 69         |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019297   | 0.019297   | 0.019297   |   0.0 |  0.03
Output  | 3.1028e-05 | 3.1028e-05 | 3.1028e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322238
Ave neighs/atom = 161.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.744407477496, Press = -1.37869823375244
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10422.09      -10422.09      -10507.003     -10507.003      328.62136      328.62136      28104.711      28104.711     -1748.3831     -1748.3831    
     66000  -10424.506     -10424.506     -10510.353     -10510.353      332.23643      332.23643      28091.462      28091.462     -1307.0046     -1307.0046    
Loop time of 69.1739 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.215 hours/ns, 14.456 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    | 69.087     | 69.087     | 69.087     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019277   | 0.019277   | 0.019277   |   0.0 |  0.03
Output  | 2.9266e-05 | 2.9266e-05 | 2.9266e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.09
Other   |            | 0.006039   |            |       |  0.01

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

Total # of neighbors = 322276
Ave neighs/atom = 161.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.774356503875, Press = -0.83763458667476
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10424.506     -10424.506     -10510.353     -10510.353      332.23643      332.23643      28091.462      28091.462     -1307.0046     -1307.0046    
     67000  -10420.883     -10420.883     -10507.721     -10507.721      336.07131      336.07131      28090.894      28090.894     -1139.9627     -1139.9627    
Loop time of 69.1478 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.462 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    | 69.061     | 69.061     | 69.061     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019195   | 0.019195   | 0.019195   |   0.0 |  0.03
Output  | 2.9426e-05 | 2.9426e-05 | 2.9426e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.09
Other   |            | 0.006005   |            |       |  0.01

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

Total # of neighbors = 322546
Ave neighs/atom = 161.273
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.828146799127, Press = -0.480306197840589
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10420.883     -10420.883     -10507.721     -10507.721      336.07131      336.07131      28090.894      28090.894     -1139.9627     -1139.9627    
     68000  -10421.184     -10421.184     -10507.165     -10507.165      332.75632      332.75632      28100.37       28100.37      -1370.9785     -1370.9785    
Loop time of 69.0413 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.178 hours/ns, 14.484 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    | 68.954     | 68.954     | 68.954     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019231   | 0.019231   | 0.019231   |   0.0 |  0.03
Output  | 3.0808e-05 | 3.0808e-05 | 3.0808e-05 |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.09
Other   |            | 0.006019   |            |       |  0.01

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

Total # of neighbors = 322526
Ave neighs/atom = 161.263
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.878292220744, Press = -0.525783708146615
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10421.184     -10421.184     -10507.165     -10507.165      332.75632      332.75632      28100.37       28100.37      -1370.9785     -1370.9785    
     69000  -10421.252     -10421.252     -10505.864     -10505.864      327.45639      327.45639      28104.213      28104.213     -1543.9416     -1543.9416    
Loop time of 69.1015 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.195 hours/ns, 14.471 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    | 69.014     | 69.014     | 69.014     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01944    | 0.01944    | 0.01944    |   0.0 |  0.03
Output  | 3.183e-05  | 3.183e-05  | 3.183e-05  |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.09
Other   |            | 0.006015   |            |       |  0.01

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

Total # of neighbors = 322536
Ave neighs/atom = 161.268
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.904687118565, Press = -0.242589620492499
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10421.252     -10421.252     -10505.864     -10505.864      327.45639      327.45639      28104.213      28104.213     -1543.9416     -1543.9416    
     70000  -10425.625     -10425.625     -10511.789     -10511.789      333.46504      333.46504      28112.329      28112.329     -2546.3867     -2546.3867    
Loop time of 69.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.201 hours/ns, 14.467 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    | 69.038     | 69.038     | 69.038     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019329   | 0.019329   | 0.019329   |   0.0 |  0.03
Output  | 3.2561e-05 | 3.2561e-05 | 3.2561e-05 |   0.0 |  0.00
Modify  | 0.061795   | 0.061795   | 0.061795   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322260
Ave neighs/atom = 161.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920804036247, Press = 0.61450815808042
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10425.625     -10425.625     -10511.789     -10511.789      333.46504      333.46504      28112.329      28112.329     -2546.3867     -2546.3867    
     71000  -10422.531     -10422.531     -10508.389     -10508.389      332.28008      332.28008      28084.032      28084.032     -798.08286     -798.08286    
Loop time of 69.0936 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.193 hours/ns, 14.473 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    | 69.007     | 69.007     | 69.007     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019237   | 0.019237   | 0.019237   |   0.0 |  0.03
Output  | 3.0157e-05 | 3.0157e-05 | 3.0157e-05 |   0.0 |  0.00
Modify  | 0.061744   | 0.061744   | 0.061744   |   0.0 |  0.09
Other   |            | 0.006019   |            |       |  0.01

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

Total # of neighbors = 322550
Ave neighs/atom = 161.275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.909862145318, Press = 0.940502418890982
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10422.531     -10422.531     -10508.389     -10508.389      332.28008      332.28008      28084.032      28084.032     -798.08286     -798.08286    
     72000  -10425.443     -10425.443     -10508.208     -10508.208      320.3079       320.3079       28052.116      28052.116      822.63265      822.63265    
Loop time of 69.1317 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.203 hours/ns, 14.465 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    | 69.045     | 69.045     | 69.045     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0192     | 0.0192     | 0.0192     |   0.0 |  0.03
Output  | 3.6148e-05 | 3.6148e-05 | 3.6148e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.09
Other   |            | 0.006034   |            |       |  0.01

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

Total # of neighbors = 322810
Ave neighs/atom = 161.405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.893958387476, Press = 0.390535194636902
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10425.443     -10425.443     -10508.208     -10508.208      320.3079       320.3079       28052.116      28052.116      822.63265      822.63265    
     73000  -10422.475     -10422.475     -10507.304     -10507.304      328.29686      328.29686      28047.452      28047.452      1416.2792      1416.2792    
Loop time of 69.2169 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.227 hours/ns, 14.447 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    | 69.13      | 69.13      | 69.13      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019251   | 0.019251   | 0.019251   |   0.0 |  0.03
Output  | 2.9035e-05 | 2.9035e-05 | 2.9035e-05 |   0.0 |  0.00
Modify  | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 323178
Ave neighs/atom = 161.589
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.89736752674, Press = 0.0415687940992676
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10422.475     -10422.475     -10507.304     -10507.304      328.29686      328.29686      28047.452      28047.452      1416.2792      1416.2792    
     74000  -10424.478     -10424.478     -10510.548     -10510.548      333.0993       333.0993       28048.724      28048.724      881.6768       881.6768     
Loop time of 69.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.263 hours/ns, 14.420 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    | 69.259     | 69.259     | 69.259     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019233   | 0.019233   | 0.019233   |   0.0 |  0.03
Output  | 3.0919e-05 | 3.0919e-05 | 3.0919e-05 |   0.0 |  0.00
Modify  | 0.061726   | 0.061726   | 0.061726   |   0.0 |  0.09
Other   |            | 0.006031   |            |       |  0.01

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

Total # of neighbors = 323242
Ave neighs/atom = 161.621
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.90402601411, Press = -0.230703867997779
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10424.478     -10424.478     -10510.548     -10510.548      333.0993       333.0993       28048.724      28048.724      881.6768       881.6768     
     75000  -10420.647     -10420.647     -10510.547     -10510.547      347.92049      347.92049      28048.195      28048.195      1061.4776      1061.4776    
Loop time of 69.2221 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.228 hours/ns, 14.446 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    | 69.135     | 69.135     | 69.135     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019207   | 0.019207   | 0.019207   |   0.0 |  0.03
Output  | 3.0578e-05 | 3.0578e-05 | 3.0578e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.09
Other   |            | 0.006014   |            |       |  0.01

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

Total # of neighbors = 323254
Ave neighs/atom = 161.627
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.8783148059, Press = -0.581738332615709
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10420.647     -10420.647     -10510.547     -10510.547      347.92049      347.92049      28048.195      28048.195      1061.4776      1061.4776    
     76000  -10426.424     -10426.424     -10510.662     -10510.662      326.01166      326.01166      28042.9        28042.9        1250.7278      1250.7278    
Loop time of 69.3026 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.251 hours/ns, 14.429 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    | 69.215     | 69.215     | 69.215     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019261   | 0.019261   | 0.019261   |   0.0 |  0.03
Output  | 3.1069e-05 | 3.1069e-05 | 3.1069e-05 |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.09
Other   |            | 0.006018   |            |       |  0.01

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

Total # of neighbors = 323144
Ave neighs/atom = 161.572
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.848138851026, Press = -0.866673053269757
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10426.424     -10426.424     -10510.662     -10510.662      326.01166      326.01166      28042.9        28042.9        1250.7278      1250.7278    
     77000  -10421.09      -10421.09      -10507.238     -10507.238      333.40263      333.40263      28059.636      28059.636      666.82995      666.82995    
Loop time of 69.3956 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.277 hours/ns, 14.410 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    | 69.309     | 69.309     | 69.309     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019321   | 0.019321   | 0.019321   |   0.0 |  0.03
Output  | 3.185e-05  | 3.185e-05  | 3.185e-05  |   0.0 |  0.00
Modify  | 0.06171    | 0.06171    | 0.06171    |   0.0 |  0.09
Other   |            | 0.006029   |            |       |  0.01

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

Total # of neighbors = 323656
Ave neighs/atom = 161.828
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.843449794288, Press = -1.14220290922623
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10421.09      -10421.09      -10507.238     -10507.238      333.40263      333.40263      28059.636      28059.636      666.82995      666.82995    
     78000  -10424.93      -10424.93      -10508.757     -10508.757      324.41751      324.41751      28071.781      28071.781     -135.5031      -135.5031     
Loop time of 69.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.237 hours/ns, 14.440 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    | 69.165     | 69.165     | 69.165     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019218   | 0.019218   | 0.019218   |   0.0 |  0.03
Output  | 3.177e-05  | 3.177e-05  | 3.177e-05  |   0.0 |  0.00
Modify  | 0.061685   | 0.061685   | 0.061685   |   0.0 |  0.09
Other   |            | 0.006014   |            |       |  0.01

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

Total # of neighbors = 322972
Ave neighs/atom = 161.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.814081858525, Press = -1.22320117133485
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10424.93      -10424.93      -10508.757     -10508.757      324.41751      324.41751      28071.781      28071.781     -135.5031      -135.5031     
     79000  -10420.095     -10420.095     -10506.987     -10506.987      336.27922      336.27922      28093.948      28093.948     -1195.7187     -1195.7187    
Loop time of 69.3231 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.256 hours/ns, 14.425 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    | 69.236     | 69.236     | 69.236     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019248   | 0.019248   | 0.019248   |   0.0 |  0.03
Output  | 3.3483e-05 | 3.3483e-05 | 3.3483e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.09
Other   |            | 0.006012   |            |       |  0.01

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

Total # of neighbors = 322784
Ave neighs/atom = 161.392
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.790887359047, Press = -1.01826186120113
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10420.095     -10420.095     -10506.987     -10506.987      336.27922      336.27922      28093.948      28093.948     -1195.7187     -1195.7187    
     80000  -10422.729     -10422.729     -10509.468     -10509.468      335.69105      335.69105      28106.678      28106.678     -2118.7039     -2118.7039    
Loop time of 69.3396 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.261 hours/ns, 14.422 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    | 69.252     | 69.252     | 69.252     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019309   | 0.019309   | 0.019309   |   0.0 |  0.03
Output  | 3.1048e-05 | 3.1048e-05 | 3.1048e-05 |   0.0 |  0.00
Modify  | 0.061726   | 0.061726   | 0.061726   |   0.0 |  0.09
Other   |            | 0.006034   |            |       |  0.01

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

Total # of neighbors = 321960
Ave neighs/atom = 160.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.797706591225, Press = -0.836986093275669
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -10422.729     -10422.729     -10509.468     -10509.468      335.69105      335.69105      28106.678      28106.678     -2118.7039     -2118.7039    
     81000  -10429.686     -10429.686     -10511.677     -10511.677      317.31534      317.31534      28118.668      28118.668     -3219.9482     -3219.9482    
Loop time of 69.1148 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.199 hours/ns, 14.469 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    | 69.028     | 69.028     | 69.028     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019199   | 0.019199   | 0.019199   |   0.0 |  0.03
Output  | 3.158e-05  | 3.158e-05  | 3.158e-05  |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.09
Other   |            | 0.006005   |            |       |  0.01

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

Total # of neighbors = 322178
Ave neighs/atom = 161.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.782262386508, Press = -0.558264600606345
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -10429.686     -10429.686     -10511.677     -10511.677      317.31534      317.31534      28118.668      28118.668     -3219.9482     -3219.9482    
     82000  -10423.528     -10423.528     -10509.033     -10509.033      330.91207      330.91207      28146.304      28146.304     -4358.5001     -4358.5001    
Loop time of 69.1441 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.463 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.057     | 69.057     | 69.057     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019193   | 0.019193   | 0.019193   |   0.0 |  0.03
Output  | 3.2972e-05 | 3.2972e-05 | 3.2972e-05 |   0.0 |  0.00
Modify  | 0.061545   | 0.061545   | 0.061545   |   0.0 |  0.09
Other   |            | 0.006025   |            |       |  0.01

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

Total # of neighbors = 322418
Ave neighs/atom = 161.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.755708045206, Press = 0.0615348664927858
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -10423.528     -10423.528     -10509.033     -10509.033      330.91207      330.91207      28146.304      28146.304     -4358.5001     -4358.5001    
     83000  -10423.666     -10423.666     -10508.079     -10508.079      326.68545      326.68545      28090.378      28090.378     -1187.7885     -1187.7885    
Loop time of 68.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.256 ns/day, 19.116 hours/ns, 14.532 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.729     | 68.729     | 68.729     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019231   | 0.019231   | 0.019231   |   0.0 |  0.03
Output  | 3.182e-05  | 3.182e-05  | 3.182e-05  |   0.0 |  0.00
Modify  | 0.061587   | 0.061587   | 0.061587   |   0.0 |  0.09
Other   |            | 0.006012   |            |       |  0.01

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

Total # of neighbors = 321988
Ave neighs/atom = 160.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.746476552413, Press = 0.145988924458745
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -10423.666     -10423.666     -10508.079     -10508.079      326.68545      326.68545      28090.378      28090.378     -1187.7885     -1187.7885    
     84000  -10422.886     -10422.886     -10506.588     -10506.588      323.93622      323.93622      28077.403      28077.403     -215.28266     -215.28266    
Loop time of 69.1668 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.213 hours/ns, 14.458 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.08      | 69.08      | 69.08      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019202   | 0.019202   | 0.019202   |   0.0 |  0.03
Output  | 3.4685e-05 | 3.4685e-05 | 3.4685e-05 |   0.0 |  0.00
Modify  | 0.061654   | 0.061654   | 0.061654   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 322606
Ave neighs/atom = 161.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.725637888327, Press = 0.155724360723696
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -10422.886     -10422.886     -10506.588     -10506.588      323.93622      323.93622      28077.403      28077.403     -215.28266     -215.28266    
     85000  -10425.688     -10425.688     -10510.688     -10510.688      328.95914      328.95914      28066.218      28066.218     -87.054951     -87.054951    
Loop time of 69.0231 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.252 ns/day, 19.173 hours/ns, 14.488 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.936     | 68.936     | 68.936     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019357   | 0.019357   | 0.019357   |   0.0 |  0.03
Output  | 3.5177e-05 | 3.5177e-05 | 3.5177e-05 |   0.0 |  0.00
Modify  | 0.061661   | 0.061661   | 0.061661   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 322606
Ave neighs/atom = 161.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.734154250565, Press = 0.270739311676751
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -10425.688     -10425.688     -10510.688     -10510.688      328.95914      328.95914      28066.218      28066.218     -87.054951     -87.054951    
     86000  -10421.494     -10421.494     -10507.849     -10507.849      334.20012      334.20012      28051.673      28051.673      891.06668      891.06668    
Loop time of 69.2244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.229 hours/ns, 14.446 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.137     | 69.137     | 69.137     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019259   | 0.019259   | 0.019259   |   0.0 |  0.03
Output  | 2.9616e-05 | 2.9616e-05 | 2.9616e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.09
Other   |            | 0.006017   |            |       |  0.01

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

Total # of neighbors = 323104
Ave neighs/atom = 161.552
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.718209768842, Press = 0.677390570009548
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -10421.494     -10421.494     -10507.849     -10507.849      334.20012      334.20012      28051.673      28051.673      891.06668      891.06668    
     87000  -10425.803     -10425.803     -10509.139     -10509.139      322.51967      322.51967      28001.099      28001.099      3708.1478      3708.1478    
Loop time of 69.348 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.263 hours/ns, 14.420 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.261     | 69.261     | 69.261     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019255   | 0.019255   | 0.019255   |   0.0 |  0.03
Output  | 3.163e-05  | 3.163e-05  | 3.163e-05  |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.09
Other   |            | 0.006034   |            |       |  0.01

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

Total # of neighbors = 322960
Ave neighs/atom = 161.48
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.705717240304, Press = 0.912909052322616
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -10425.803     -10425.803     -10509.139     -10509.139      322.51967      322.51967      28001.099      28001.099      3708.1478      3708.1478    
     88000  -10420.664     -10420.664     -10507.954     -10507.954      337.82219      337.82219      28026.876      28026.876      2547.2568      2547.2568    
Loop time of 69.2029 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.223 hours/ns, 14.450 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    | 69.116     | 69.116     | 69.116     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019218   | 0.019218   | 0.019218   |   0.0 |  0.03
Output  | 3.0418e-05 | 3.0418e-05 | 3.0418e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 323974
Ave neighs/atom = 161.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.685530942434, Press = 0.0591582233287616
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -10420.664     -10420.664     -10507.954     -10507.954      337.82219      337.82219      28026.876      28026.876      2547.2568      2547.2568    
     89000  -10423.497     -10423.497     -10508.302     -10508.302      328.2049       328.2049       28029.59       28029.59       2260.3374      2260.3374    
Loop time of 69.4338 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.244 ns/day, 19.287 hours/ns, 14.402 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.347     | 69.347     | 69.347     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01922    | 0.01922    | 0.01922    |   0.0 |  0.03
Output  | 3.3183e-05 | 3.3183e-05 | 3.3183e-05 |   0.0 |  0.00
Modify  | 0.061665   | 0.061665   | 0.061665   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 323758
Ave neighs/atom = 161.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.691568225607, Press = -0.181504306881768
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -10423.497     -10423.497     -10508.302     -10508.302      328.2049       328.2049       28029.59       28029.59       2260.3374      2260.3374    
     90000  -10420.282     -10420.282     -10507.822     -10507.822      338.78671      338.78671      28043.483      28043.483      1613.3903      1613.3903    
Loop time of 69.2037 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.223 hours/ns, 14.450 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.117     | 69.117     | 69.117     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019172   | 0.019172   | 0.019172   |   0.0 |  0.03
Output  | 3.1329e-05 | 3.1329e-05 | 3.1329e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.09
Other   |            | 0.006012   |            |       |  0.01

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

Total # of neighbors = 323438
Ave neighs/atom = 161.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 = 332.743474239073, Press = -0.625404245878042
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -10420.282     -10420.282     -10507.822     -10507.822      338.78671      338.78671      28043.483      28043.483      1613.3903      1613.3903    
     91000  -10424.191     -10424.191     -10510.183     -10510.183      332.79606      332.79606      28052.517      28052.517      711.43231      711.43231    
Loop time of 69.1962 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.221 hours/ns, 14.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.109     | 69.109     | 69.109     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019242   | 0.019242   | 0.019242   |   0.0 |  0.03
Output  | 3.4815e-05 | 3.4815e-05 | 3.4815e-05 |   0.0 |  0.00
Modify  | 0.061576   | 0.061576   | 0.061576   |   0.0 |  0.09
Other   |            | 0.006019   |            |       |  0.01

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

Total # of neighbors = 323196
Ave neighs/atom = 161.598
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.727974856511, Press = -0.852124136649739
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -10424.191     -10424.191     -10510.183     -10510.183      332.79606      332.79606      28052.517      28052.517      711.43231      711.43231    
     92000  -10422.834     -10422.834     -10508.876     -10508.876      332.99243      332.99243      28079.017      28079.017     -626.43396     -626.43396    
Loop time of 69.201 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.222 hours/ns, 14.451 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    | 69.114     | 69.114     | 69.114     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019245   | 0.019245   | 0.019245   |   0.0 |  0.03
Output  | 3.5657e-05 | 3.5657e-05 | 3.5657e-05 |   0.0 |  0.00
Modify  | 0.061637   | 0.061637   | 0.061637   |   0.0 |  0.09
Other   |            | 0.006006   |            |       |  0.01

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

Total # of neighbors = 323352
Ave neighs/atom = 161.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 = 332.729028293667, Press = -0.860221647568446
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -10422.834     -10422.834     -10508.876     -10508.876      332.99243      332.99243      28079.017      28079.017     -626.43396     -626.43396    
     93000  -10421.684     -10421.684     -10508.092     -10508.092      334.408        334.408        28093.26       28093.26      -1104.7149     -1104.7149    
Loop time of 69.2681 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.437 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.181     | 69.181     | 69.181     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019256   | 0.019256   | 0.019256   |   0.0 |  0.03
Output  | 3.1199e-05 | 3.1199e-05 | 3.1199e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.09
Other   |            | 0.006025   |            |       |  0.01

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

Total # of neighbors = 322548
Ave neighs/atom = 161.274
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.73608257833, Press = -0.598989455533841
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -10421.684     -10421.684     -10508.092     -10508.092      334.408        334.408        28093.26       28093.26      -1104.7149     -1104.7149    
     94000  -10425.286     -10425.286     -10510.346     -10510.346      329.18754      329.18754      28092.179      28092.179     -1434.8315     -1434.8315    
Loop time of 68.9853 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.252 ns/day, 19.163 hours/ns, 14.496 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.898     | 68.898     | 68.898     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019205   | 0.019205   | 0.019205   |   0.0 |  0.03
Output  | 3.194e-05  | 3.194e-05  | 3.194e-05  |   0.0 |  0.00
Modify  | 0.061598   | 0.061598   | 0.061598   |   0.0 |  0.09
Other   |            | 0.006033   |            |       |  0.01

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

Total # of neighbors = 322630
Ave neighs/atom = 161.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.722394680083, Press = -0.388231142695576
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -10425.286     -10425.286     -10510.346     -10510.346      329.18754      329.18754      28092.179      28092.179     -1434.8315     -1434.8315    
     95000  -10423.012     -10423.012     -10507.574     -10507.574      327.26438      327.26438      28089.941      28089.941     -1014.7037     -1014.7037    
Loop time of 69.1891 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.219 hours/ns, 14.453 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.102     | 69.102     | 69.102     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019271   | 0.019271   | 0.019271   |   0.0 |  0.03
Output  | 3.0057e-05 | 3.0057e-05 | 3.0057e-05 |   0.0 |  0.00
Modify  | 0.061562   | 0.061562   | 0.061562   |   0.0 |  0.09
Other   |            | 0.006032   |            |       |  0.01

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

Total # of neighbors = 322974
Ave neighs/atom = 161.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.697033144727, Press = -0.176586342470036
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -10423.012     -10423.012     -10507.574     -10507.574      327.26438      327.26438      28089.941      28089.941     -1014.7037     -1014.7037    
     96000  -10422.603     -10422.603     -10510.127     -10510.127      338.72769      338.72769      28091.721      28091.721     -969.91787     -969.91787    
Loop time of 69.287 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.246 hours/ns, 14.433 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.2       | 69.2       | 69.2       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019257   | 0.019257   | 0.019257   |   0.0 |  0.03
Output  | 3.0498e-05 | 3.0498e-05 | 3.0498e-05 |   0.0 |  0.00
Modify  | 0.06154    | 0.06154    | 0.06154    |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322638
Ave neighs/atom = 161.319
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.702994374883, Press = -0.128600330260132
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -10422.603     -10422.603     -10510.127     -10510.127      338.72769      338.72769      28091.721      28091.721     -969.91787     -969.91787    
     97000  -10430.079     -10430.079     -10511.339     -10511.339      314.48568      314.48568      28076.24       28076.24      -729.78331     -729.78331    
Loop time of 69.2552 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.238 hours/ns, 14.439 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    | 69.168     | 69.168     | 69.168     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019165   | 0.019165   | 0.019165   |   0.0 |  0.03
Output  | 3.0978e-05 | 3.0978e-05 | 3.0978e-05 |   0.0 |  0.00
Modify  | 0.06156    | 0.06156    | 0.06156    |   0.0 |  0.09
Other   |            | 0.00603    |            |       |  0.01

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

Total # of neighbors = 323100
Ave neighs/atom = 161.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.683047628658, Press = 0.115152827849248
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -10430.079     -10430.079     -10511.339     -10511.339      314.48568      314.48568      28076.24       28076.24      -729.78331     -729.78331    
     98000  -10419.864     -10419.864     -10508.356     -10508.356      342.47548      342.47548      28087.326      28087.326     -736.27615     -736.27615    
Loop time of 69.2659 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.437 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.179     | 69.179     | 69.179     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019272   | 0.019272   | 0.019272   |   0.0 |  0.03
Output  | 3.6038e-05 | 3.6038e-05 | 3.6038e-05 |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.09
Other   |            | 0.006013   |            |       |  0.01

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

Total # of neighbors = 323348
Ave neighs/atom = 161.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.669453049262, Press = 0.497099375676263
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -10419.864     -10419.864     -10508.356     -10508.356      342.47548      342.47548      28087.326      28087.326     -736.27615     -736.27615    
     99000  -10423.347     -10423.347     -10507.722     -10507.722      326.54149      326.54149      28064.677      28064.677      376.41514      376.41514    
Loop time of 69.3193 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.255 hours/ns, 14.426 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.232     | 69.232     | 69.232     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019194   | 0.019194   | 0.019194   |   0.0 |  0.03
Output  | 2.9265e-05 | 2.9265e-05 | 2.9265e-05 |   0.0 |  0.00
Modify  | 0.061604   | 0.061604   | 0.061604   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 322918
Ave neighs/atom = 161.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.687215065048, Press = 0.535760358128785
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -10423.347     -10423.347     -10507.722     -10507.722      326.54149      326.54149      28064.677      28064.677      376.41514      376.41514    
    100000  -10417.624     -10417.624     -10505.266     -10505.266      339.18223      339.18223      28057.099      28057.099      1209.5317      1209.5317    
Loop time of 69.2528 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.237 hours/ns, 14.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.166     | 69.166     | 69.166     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019284   | 0.019284   | 0.019284   |   0.0 |  0.03
Output  | 3.0207e-05 | 3.0207e-05 | 3.0207e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.09
Other   |            | 0.00603    |            |       |  0.01

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

Total # of neighbors = 322980
Ave neighs/atom = 161.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.72647239697, Press = 0.431784677780008
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -10417.624     -10417.624     -10505.266     -10505.266      339.18223      339.18223      28057.099      28057.099      1209.5317      1209.5317    
    101000  -10423.185     -10423.185     -10508.084     -10508.084      328.56824      328.56824      28044.358      28044.358      1410.8603      1410.8603    
Loop time of 69.2714 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.242 hours/ns, 14.436 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    | 69.184     | 69.184     | 69.184     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019221   | 0.019221   | 0.019221   |   0.0 |  0.03
Output  | 3.3002e-05 | 3.3002e-05 | 3.3002e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.09
Other   |            | 0.00602    |            |       |  0.01

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

Total # of neighbors = 322908
Ave neighs/atom = 161.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 = 332.738044210931, Press = 0.0871524878032724
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -10423.185     -10423.185     -10508.084     -10508.084      328.56824      328.56824      28044.358      28044.358      1410.8603      1410.8603    
    102000  -10422.681     -10422.681     -10507.705     -10507.705      329.05231      329.05231      28052.606      28052.606      933.98803      933.98803    
Loop time of 69.2641 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.240 hours/ns, 14.437 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.177     | 69.177     | 69.177     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019184   | 0.019184   | 0.019184   |   0.0 |  0.03
Output  | 3.3654e-05 | 3.3654e-05 | 3.3654e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.09
Other   |            | 0.006032   |            |       |  0.01

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

Total # of neighbors = 323230
Ave neighs/atom = 161.615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.755630197687, Press = -0.154850507988154
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -10422.681     -10422.681     -10507.705     -10507.705      329.05231      329.05231      28052.606      28052.606      933.98803      933.98803    
    103000  -10424.571     -10424.571     -10509.82      -10509.82       329.92342      329.92342      28046.291      28046.291      1101.693       1101.693     
Loop time of 69.4207 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.284 hours/ns, 14.405 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.334     | 69.334     | 69.334     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019169   | 0.019169   | 0.019169   |   0.0 |  0.03
Output  | 3.2781e-05 | 3.2781e-05 | 3.2781e-05 |   0.0 |  0.00
Modify  | 0.061649   | 0.061649   | 0.061649   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

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

Total # of neighbors = 323274
Ave neighs/atom = 161.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.765022578858, Press = -0.21275375043148
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -10424.571     -10424.571     -10509.82      -10509.82       329.92342      329.92342      28046.291      28046.291      1101.693       1101.693     
    104000  -10417.85      -10417.85      -10502.575     -10502.575      327.89445      327.89445      28044.64       28044.64       1955.7442      1955.7442    
Loop time of 69.1575 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.210 hours/ns, 14.460 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.071     | 69.071     | 69.071     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019165   | 0.019165   | 0.019165   |   0.0 |  0.03
Output  | 3.5617e-05 | 3.5617e-05 | 3.5617e-05 |   0.0 |  0.00
Modify  | 0.061676   | 0.061676   | 0.061676   |   0.0 |  0.09
Other   |            | 0.006013   |            |       |  0.01

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

Total # of neighbors = 323370
Ave neighs/atom = 161.685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.789472609215, Press = -0.431959119372952
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -10417.85      -10417.85      -10502.575     -10502.575      327.89445      327.89445      28044.64       28044.64       1955.7442      1955.7442    
    105000  -10423.306     -10423.306     -10508.903     -10508.903      331.26828      331.26828      28015.703      28015.703      2895.5674      2895.5674    
Loop time of 69.4299 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.244 ns/day, 19.286 hours/ns, 14.403 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    | 69.343     | 69.343     | 69.343     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019165   | 0.019165   | 0.019165   |   0.0 |  0.03
Output  | 3.716e-05  | 3.716e-05  | 3.716e-05  |   0.0 |  0.00
Modify  | 0.061742   | 0.061742   | 0.061742   |   0.0 |  0.09
Other   |            | 0.006049   |            |       |  0.01

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

Total # of neighbors = 322850
Ave neighs/atom = 161.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.812076630622, Press = -1.05098683069561
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -10423.306     -10423.306     -10508.903     -10508.903      331.26828      331.26828      28015.703      28015.703      2895.5674      2895.5674    
    106000  -10420.174     -10420.174     -10508.692     -10508.692      342.57413      342.57413      28059.596      28059.596      716.42449      716.42449    
Loop time of 69.3673 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.269 hours/ns, 14.416 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.28      | 69.28      | 69.28      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019198   | 0.019198   | 0.019198   |   0.0 |  0.03
Output  | 3.3293e-05 | 3.3293e-05 | 3.3293e-05 |   0.0 |  0.00
Modify  | 0.061786   | 0.061786   | 0.061786   |   0.0 |  0.09
Other   |            | 0.006062   |            |       |  0.01

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

Total # of neighbors = 323784
Ave neighs/atom = 161.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.842712597176, Press = -0.986193838721958
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -10420.174     -10420.174     -10508.692     -10508.692      342.57413      342.57413      28059.596      28059.596      716.42449      716.42449    
    107000  -10426.204     -10426.204     -10510.693     -10510.693      326.97936      326.97936      28072.761      28072.761     -469.43562     -469.43562    
Loop time of 69.2344 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.232 hours/ns, 14.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.147     | 69.147     | 69.147     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019227   | 0.019227   | 0.019227   |   0.0 |  0.03
Output  | 3.2692e-05 | 3.2692e-05 | 3.2692e-05 |   0.0 |  0.00
Modify  | 0.061752   | 0.061752   | 0.061752   |   0.0 |  0.09
Other   |            | 0.00604    |            |       |  0.01

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

Total # of neighbors = 322958
Ave neighs/atom = 161.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.847345473469, Press = -0.470480546011588
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -10426.204     -10426.204     -10510.693     -10510.693      326.97936      326.97936      28072.761      28072.761     -469.43562     -469.43562    
    108000  -10420.517     -10420.517     -10508.102     -10508.102      338.96255      338.96255      28085.06       28085.06      -828.60156     -828.60156    
Loop time of 69.4607 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.244 ns/day, 19.295 hours/ns, 14.397 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.374     | 69.374     | 69.374     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019237   | 0.019237   | 0.019237   |   0.0 |  0.03
Output  | 3.3774e-05 | 3.3774e-05 | 3.3774e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.09
Other   |            | 0.006047   |            |       |  0.01

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

Total # of neighbors = 323270
Ave neighs/atom = 161.635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.828223896826, Press = -0.323927314378971
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -10420.517     -10420.517     -10508.102     -10508.102      338.96255      338.96255      28085.06       28085.06      -828.60156     -828.60156    
    109000  -10422.18      -10422.18      -10507.288     -10507.288      329.3774       329.3774       28101.807      28101.807     -1738.5321     -1738.5321    
Loop time of 69.2538 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.237 hours/ns, 14.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.167     | 69.167     | 69.167     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019204   | 0.019204   | 0.019204   |   0.0 |  0.03
Output  | 3.4605e-05 | 3.4605e-05 | 3.4605e-05 |   0.0 |  0.00
Modify  | 0.061837   | 0.061837   | 0.061837   |   0.0 |  0.09
Other   |            | 0.00605    |            |       |  0.01

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

Total # of neighbors = 322796
Ave neighs/atom = 161.398
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.836384692639, Press = -0.482821886335611
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -10422.18      -10422.18      -10507.288     -10507.288      329.3774       329.3774       28101.807      28101.807     -1738.5321     -1738.5321    
    110000  -10419.741     -10419.741     -10506.973     -10506.973      337.59748      337.59748      28134.331      28134.331     -3269.7057     -3269.7057    
Loop time of 69.2466 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.235 hours/ns, 14.441 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    | 69.16      | 69.16      | 69.16      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01924    | 0.01924    | 0.01924    |   0.0 |  0.03
Output  | 3.3393e-05 | 3.3393e-05 | 3.3393e-05 |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 322358
Ave neighs/atom = 161.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.875032184323, Press = -0.209599599860507
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -10419.741     -10419.741     -10506.973     -10506.973      337.59748      337.59748      28134.331      28134.331     -3269.7057     -3269.7057    
    111000  -10425.648     -10425.648     -10510.686     -10510.686      329.10553      329.10553      28112.81       28112.81      -2656.6691     -2656.6691    
Loop time of 69.2494 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.236 hours/ns, 14.441 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.163     | 69.163     | 69.163     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019169   | 0.019169   | 0.019169   |   0.0 |  0.03
Output  | 3.7801e-05 | 3.7801e-05 | 3.7801e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.09
Other   |            | 0.006018   |            |       |  0.01

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

Total # of neighbors = 322030
Ave neighs/atom = 161.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.880508398964, Press = 0.205270416857716
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -10425.648     -10425.648     -10510.686     -10510.686      329.10553      329.10553      28112.81       28112.81      -2656.6691     -2656.6691    
    112000  -10421.552     -10421.552     -10505.775     -10505.775      325.9519       325.9519       28089.026      28089.026     -660.72209     -660.72209    
Loop time of 69.1839 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.218 hours/ns, 14.454 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.097     | 69.097     | 69.097     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019237   | 0.019237   | 0.019237   |   0.0 |  0.03
Output  | 3.0597e-05 | 3.0597e-05 | 3.0597e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.09
Other   |            | 0.006044   |            |       |  0.01

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

Total # of neighbors = 322618
Ave neighs/atom = 161.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863130984491, Press = 0.107295238858695
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -10421.552     -10421.552     -10505.775     -10505.775      325.9519       325.9519       28089.026      28089.026     -660.72209     -660.72209    
    113000  -10424.012     -10424.012     -10508.927     -10508.927      328.62614      328.62614      28074.052      28074.052     -278.82028     -278.82028    
Loop time of 69.1533 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.209 hours/ns, 14.461 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.066     | 69.066     | 69.066     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019303   | 0.019303   | 0.019303   |   0.0 |  0.03
Output  | 3.2471e-05 | 3.2471e-05 | 3.2471e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.09
Other   |            | 0.006036   |            |       |  0.01

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

Total # of neighbors = 322556
Ave neighs/atom = 161.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 = 332.854438775159, Press = 0.0577063296655543
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -10424.012     -10424.012     -10508.927     -10508.927      328.62614      328.62614      28074.052      28074.052     -278.82028     -278.82028    
    114000  -10419.106     -10419.106     -10506.955     -10506.955      339.98364      339.98364      28068.115      28068.115      417.85216      417.85216    
Loop time of 69.0963 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.193 hours/ns, 14.473 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.009     | 69.009     | 69.009     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019261   | 0.019261   | 0.019261   |   0.0 |  0.03
Output  | 3.6419e-05 | 3.6419e-05 | 3.6419e-05 |   0.0 |  0.00
Modify  | 0.061777   | 0.061777   | 0.061777   |   0.0 |  0.09
Other   |            | 0.006029   |            |       |  0.01

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

Total # of neighbors = 322844
Ave neighs/atom = 161.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863697528516, Press = 0.247335799834691
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -10419.106     -10419.106     -10506.955     -10506.955      339.98364      339.98364      28068.115      28068.115      417.85216      417.85216    
    115000  -10423.98      -10423.98      -10510.172     -10510.172      333.57164      333.57164      28046.341      28046.341      1395.333       1395.333     
Loop time of 69.1477 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.462 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.061     | 69.061     | 69.061     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019182   | 0.019182   | 0.019182   |   0.0 |  0.03
Output  | 3.4545e-05 | 3.4545e-05 | 3.4545e-05 |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.09
Other   |            | 0.006021   |            |       |  0.01

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

Total # of neighbors = 322928
Ave neighs/atom = 161.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.889806905871, Press = 0.38330220904582
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -10423.98      -10423.98      -10510.172     -10510.172      333.57164      333.57164      28046.341      28046.341      1395.333       1395.333     
    116000  -10422.439     -10422.439     -10507.234     -10507.234      328.16172      328.16172      28020.064      28020.064      2915.4093      2915.4093    
Loop time of 69.2682 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.241 hours/ns, 14.437 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.181     | 69.181     | 69.181     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019192   | 0.019192   | 0.019192   |   0.0 |  0.03
Output  | 3.2812e-05 | 3.2812e-05 | 3.2812e-05 |   0.0 |  0.00
Modify  | 0.061726   | 0.061726   | 0.061726   |   0.0 |  0.09
Other   |            | 0.00601    |            |       |  0.01

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

Total # of neighbors = 323444
Ave neighs/atom = 161.722
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.903082475072, Press = 0.379610677109632
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -10422.439     -10422.439     -10507.234     -10507.234      328.16172      328.16172      28020.064      28020.064      2915.4093      2915.4093    
    117000  -10422.728     -10422.728     -10506.848     -10506.848      325.55255      325.55255      27999.236      27999.236      4074.8398      4074.8398    
Loop time of 69.3808 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.272 hours/ns, 14.413 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.294     | 69.294     | 69.294     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019194   | 0.019194   | 0.019194   |   0.0 |  0.03
Output  | 3.5938e-05 | 3.5938e-05 | 3.5938e-05 |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.09
Other   |            | 0.006032   |            |       |  0.01

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

Total # of neighbors = 323686
Ave neighs/atom = 161.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.882750552033, Press = 0.192137283559763
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -10422.728     -10422.728     -10506.848     -10506.848      325.55255      325.55255      27999.236      27999.236      4074.8398      4074.8398    
    118000  -10425.274     -10425.274     -10509.077     -10509.077      324.32646      324.32646      28038.128      28038.128      1644.5531      1644.5531    
Loop time of 69.2712 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.242 hours/ns, 14.436 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    | 69.184     | 69.184     | 69.184     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019218   | 0.019218   | 0.019218   |   0.0 |  0.03
Output  | 3.6919e-05 | 3.6919e-05 | 3.6919e-05 |   0.0 |  0.00
Modify  | 0.061688   | 0.061688   | 0.061688   |   0.0 |  0.09
Other   |            | 0.006001   |            |       |  0.01

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

Total # of neighbors = 323688
Ave neighs/atom = 161.844
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.873708768778, Press = -0.134849355144682
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -10425.274     -10425.274     -10509.077     -10509.077      324.32646      324.32646      28038.128      28038.128      1644.5531      1644.5531    
    119000  -10421.561     -10421.561     -10506.969     -10506.969      330.53823      330.53823      28053.519      28053.519      996.32354      996.32354    
Loop time of 69.1944 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.221 hours/ns, 14.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.107     | 69.107     | 69.107     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019317   | 0.019317   | 0.019317   |   0.0 |  0.03
Output  | 3.3503e-05 | 3.3503e-05 | 3.3503e-05 |   0.0 |  0.00
Modify  | 0.061702   | 0.061702   | 0.061702   |   0.0 |  0.09
Other   |            | 0.00601    |            |       |  0.01

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

Total # of neighbors = 323226
Ave neighs/atom = 161.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.847947192452, Press = -0.258604913371597
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -10421.561     -10421.561     -10506.969     -10506.969      330.53823      330.53823      28053.519      28053.519      996.32354      996.32354    
    120000  -10425.416     -10425.416     -10510.882     -10510.882      330.76231      330.76231      28057.53       28057.53       452.71118      452.71118    
Loop time of 69.3873 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.274 hours/ns, 14.412 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.3       | 69.3       | 69.3       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019193   | 0.019193   | 0.019193   |   0.0 |  0.03
Output  | 3.3222e-05 | 3.3222e-05 | 3.3222e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.09
Other   |            | 0.006021   |            |       |  0.01

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

Total # of neighbors = 323036
Ave neighs/atom = 161.518
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.841097844149, Press = -0.374833952983489
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -10425.416     -10425.416     -10510.882     -10510.882      330.76231      330.76231      28057.53       28057.53       452.71118      452.71118    
    121000  -10422.751     -10422.751     -10506.549     -10506.549      324.30658      324.30658      28085.374      28085.374     -795.88778     -795.88778    
Loop time of 69.2009 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.222 hours/ns, 14.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.114     | 69.114     | 69.114     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019292   | 0.019292   | 0.019292   |   0.0 |  0.03
Output  | 3.2982e-05 | 3.2982e-05 | 3.2982e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.09
Other   |            | 0.006026   |            |       |  0.01

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

Total # of neighbors = 323278
Ave neighs/atom = 161.639
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.860876800351, Press = -0.676547233095468
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -10422.751     -10422.751     -10506.549     -10506.549      324.30658      324.30658      28085.374      28085.374     -795.88778     -795.88778    
    122000  -10422.271     -10422.271     -10507.493     -10507.493      329.81706      329.81706      28125.516      28125.516     -2964.5075     -2964.5075    
Loop time of 69.1233 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.201 hours/ns, 14.467 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.036     | 69.036     | 69.036     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01927    | 0.01927    | 0.01927    |   0.0 |  0.03
Output  | 3.3033e-05 | 3.3033e-05 | 3.3033e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.09
Other   |            | 0.006027   |            |       |  0.01

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

Total # of neighbors = 322518
Ave neighs/atom = 161.259
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872465581721, Press = -0.694516197982857
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -10422.271     -10422.271     -10507.493     -10507.493      329.81706      329.81706      28125.516      28125.516     -2964.5075     -2964.5075    
    123000  -10419.434     -10419.434     -10505.98      -10505.98       334.9438       334.9438       28122.045      28122.045     -2771.855      -2771.855     
Loop time of 69.2989 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.250 hours/ns, 14.430 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    | 69.212     | 69.212     | 69.212     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019141   | 0.019141   | 0.019141   |   0.0 |  0.03
Output  | 3.3252e-05 | 3.3252e-05 | 3.3252e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.09
Other   |            | 0.006013   |            |       |  0.01

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

Total # of neighbors = 322018
Ave neighs/atom = 161.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.897781708905, Press = -0.290876450397055
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -10419.434     -10419.434     -10505.98      -10505.98       334.9438       334.9438       28122.045      28122.045     -2771.855      -2771.855     
    124000  -10421.43      -10421.43      -10507.934     -10507.934      334.77614      334.77614      28105.842      28105.842     -1916.7209     -1916.7209    
Loop time of 69.0503 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.251 ns/day, 19.181 hours/ns, 14.482 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.963     | 68.963     | 68.963     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019192   | 0.019192   | 0.019192   |   0.0 |  0.03
Output  | 3.8983e-05 | 3.8983e-05 | 3.8983e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.09
Other   |            | 0.006014   |            |       |  0.01

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

Total # of neighbors = 322030
Ave neighs/atom = 161.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.892664254244, Press = -0.103585611455927
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -10421.43      -10421.43      -10507.934     -10507.934      334.77614      334.77614      28105.842      28105.842     -1916.7209     -1916.7209    
    125000  -10425.544     -10425.544     -10510.608     -10510.608      329.20408      329.20408      28093.191      28093.191     -1472.7139     -1472.7139    
Loop time of 69.0924 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.192 hours/ns, 14.473 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.005     | 69.005     | 69.005     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019296   | 0.019296   | 0.019296   |   0.0 |  0.03
Output  | 3.2401e-05 | 3.2401e-05 | 3.2401e-05 |   0.0 |  0.00
Modify  | 0.061719   | 0.061719   | 0.061719   |   0.0 |  0.09
Other   |            | 0.006015   |            |       |  0.01

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

Total # of neighbors = 322464
Ave neighs/atom = 161.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.883798004026, Press = 0.0494269707405825
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -10425.544     -10425.544     -10510.608     -10510.608      329.20408      329.20408      28093.191      28093.191     -1472.7139     -1472.7139    
    126000  -10422.186     -10422.186     -10511.421     -10511.421      345.34707      345.34707      28090.836      28090.836     -1326.0106     -1326.0106    
Loop time of 69.4487 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.244 ns/day, 19.291 hours/ns, 14.399 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.362     | 69.362     | 69.362     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01921    | 0.01921    | 0.01921    |   0.0 |  0.03
Output  | 3.2411e-05 | 3.2411e-05 | 3.2411e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.09
Other   |            | 0.006015   |            |       |  0.01

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

Total # of neighbors = 322996
Ave neighs/atom = 161.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.861489188465, Press = 0.157643668864585
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -10422.186     -10422.186     -10511.421     -10511.421      345.34707      345.34707      28090.836      28090.836     -1326.0106     -1326.0106    
    127000  -10426.127     -10426.127     -10510.36      -10510.36       325.99187      325.99187      28076.514      28076.514     -603.90498     -603.90498    
Loop time of 69.2168 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.227 hours/ns, 14.447 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    | 69.13      | 69.13      | 69.13      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019361   | 0.019361   | 0.019361   |   0.0 |  0.03
Output  | 3.2311e-05 | 3.2311e-05 | 3.2311e-05 |   0.0 |  0.00
Modify  | 0.061647   | 0.061647   | 0.061647   |   0.0 |  0.09
Other   |            | 0.006015   |            |       |  0.01

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

Total # of neighbors = 322646
Ave neighs/atom = 161.323
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.852209171141, Press = 0.396761031517313
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -10426.127     -10426.127     -10510.36      -10510.36       325.99187      325.99187      28076.514      28076.514     -603.90498     -603.90498    
    128000  -10421.166     -10421.166     -10507.161     -10507.161      332.81135      332.81135      28062.245      28062.245      662.44393      662.44393    
Loop time of 69.2253 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.229 hours/ns, 14.446 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.138     | 69.138     | 69.138     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019196   | 0.019196   | 0.019196   |   0.0 |  0.03
Output  | 3.3313e-05 | 3.3313e-05 | 3.3313e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.09
Other   |            | 0.006021   |            |       |  0.01

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

Total # of neighbors = 323070
Ave neighs/atom = 161.535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.844049903156, Press = 0.70832167199372
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -10421.166     -10421.166     -10507.161     -10507.161      332.81135      332.81135      28062.245      28062.245      662.44393      662.44393    
    129000  -10422.152     -10422.152     -10508.653     -10508.653      334.76727      334.76727      28043.847      28043.847      1395.0217      1395.0217    
Loop time of 69.2876 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.247 hours/ns, 14.433 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.201     | 69.201     | 69.201     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019216   | 0.019216   | 0.019216   |   0.0 |  0.03
Output  | 3.2612e-05 | 3.2612e-05 | 3.2612e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.09
Other   |            | 0.006001   |            |       |  0.01

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

Total # of neighbors = 322778
Ave neighs/atom = 161.389
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.848492724232, Press = 0.369757646065629
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -10422.152     -10422.152     -10508.653     -10508.653      334.76727      334.76727      28043.847      28043.847      1395.0217      1395.0217    
    130000  -10420.664     -10420.664     -10508.043     -10508.043      338.1649       338.1649       28052.854      28052.854      1077.6196      1077.6196    
Loop time of 69.2337 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.232 hours/ns, 14.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.147     | 69.147     | 69.147     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019179   | 0.019179   | 0.019179   |   0.0 |  0.03
Output  | 4.0326e-05 | 4.0326e-05 | 4.0326e-05 |   0.0 |  0.00
Modify  | 0.061692   | 0.061692   | 0.061692   |   0.0 |  0.09
Other   |            | 0.006011   |            |       |  0.01

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

Total # of neighbors = 323106
Ave neighs/atom = 161.553
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.866882537903, Press = -0.00284657501608141
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -10420.664     -10420.664     -10508.043     -10508.043      338.1649       338.1649       28052.854      28052.854      1077.6196      1077.6196    
    131000  -10426.008     -10426.008     -10509.053     -10509.053      321.39338      321.39338      28046.313      28046.313      1036.9929      1036.9929    
Loop time of 69.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.208 hours/ns, 14.461 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.063     | 69.063     | 69.063     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019271   | 0.019271   | 0.019271   |   0.0 |  0.03
Output  | 3.6739e-05 | 3.6739e-05 | 3.6739e-05 |   0.0 |  0.00
Modify  | 0.061686   | 0.061686   | 0.061686   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

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

Total # of neighbors = 323154
Ave neighs/atom = 161.577
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.865612889337, Press = -0.102736514522371
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -10426.008     -10426.008     -10509.053     -10509.053      321.39338      321.39338      28046.313      28046.313      1036.9929      1036.9929    
    132000  -10421.913     -10421.913     -10508.676     -10508.676      335.78206      335.78206      28057.567      28057.567      625.4318       625.4318     
Loop time of 69.2333 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.231 hours/ns, 14.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.146     | 69.146     | 69.146     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019185   | 0.019185   | 0.019185   |   0.0 |  0.03
Output  | 3.196e-05  | 3.196e-05  | 3.196e-05  |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

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

Total # of neighbors = 323162
Ave neighs/atom = 161.581
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.866556859886, Press = -0.239509541198843
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -10421.913     -10421.913     -10508.676     -10508.676      335.78206      335.78206      28057.567      28057.567      625.4318       625.4318     
    133000  -10423.762     -10423.762     -10509.828     -10509.828      333.08491      333.08491      28057.98       28057.98       556.49123      556.49123    
Loop time of 69.1945 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.221 hours/ns, 14.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.108     | 69.108     | 69.108     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019212   | 0.019212   | 0.019212   |   0.0 |  0.03
Output  | 3.3112e-05 | 3.3112e-05 | 3.3112e-05 |   0.0 |  0.00
Modify  | 0.06168    | 0.06168    | 0.06168    |   0.0 |  0.09
Other   |            | 0.006017   |            |       |  0.01

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

Total # of neighbors = 323008
Ave neighs/atom = 161.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.869525940082, Press = -0.760537424558937
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -10423.762     -10423.762     -10509.828     -10509.828      333.08491      333.08491      28057.98       28057.98       556.49123      556.49123    
    134000  -10418.124     -10418.124     -10507.525     -10507.525      345.99194      345.99194      28094.608      28094.608     -960.60369     -960.60369    
Loop time of 69.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.198 hours/ns, 14.469 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.025     | 69.025     | 69.025     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019401   | 0.019401   | 0.019401   |   0.0 |  0.03
Output  | 3.3343e-05 | 3.3343e-05 | 3.3343e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.09
Other   |            | 0.006027   |            |       |  0.01

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

Total # of neighbors = 322890
Ave neighs/atom = 161.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.890555336412, Press = -0.802037807981183
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -10418.124     -10418.124     -10507.525     -10507.525      345.99194      345.99194      28094.608      28094.608     -960.60369     -960.60369    
    135000  -10423.688     -10423.688     -10508.775     -10508.775      329.29504      329.29504      28087.725      28087.725     -886.33613     -886.33613    
Loop time of 69.1359 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.204 hours/ns, 14.464 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.049     | 69.049     | 69.049     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019228   | 0.019228   | 0.019228   |   0.0 |  0.03
Output  | 3.2782e-05 | 3.2782e-05 | 3.2782e-05 |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.09
Other   |            | 0.006018   |            |       |  0.01

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

Total # of neighbors = 322500
Ave neighs/atom = 161.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 = 332.905567462184, Press = -0.275400286153302
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -10423.688     -10423.688     -10508.775     -10508.775      329.29504      329.29504      28087.725      28087.725     -886.33613     -886.33613    
    136000  -10421.278     -10421.278     -10506.323     -10506.323      329.13505      329.13505      28090.056      28090.056     -791.69947     -791.69947    
Loop time of 69.1269 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.202 hours/ns, 14.466 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.04      | 69.04      | 69.04      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019239   | 0.019239   | 0.019239   |   0.0 |  0.03
Output  | 3.3504e-05 | 3.3504e-05 | 3.3504e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

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

Total # of neighbors = 322712
Ave neighs/atom = 161.356
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907876430192, Press = -0.0781167575145195
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -10421.278     -10421.278     -10506.323     -10506.323      329.13505      329.13505      28090.056      28090.056     -791.69947     -791.69947    
    137000  -10429.186     -10429.186     -10510.795     -10510.795      315.83642      315.83642      28075.562      28075.562     -647.07443     -647.07443    
Loop time of 69.0332 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.252 ns/day, 19.176 hours/ns, 14.486 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.946     | 68.946     | 68.946     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019195   | 0.019195   | 0.019195   |   0.0 |  0.03
Output  | 3.5868e-05 | 3.5868e-05 | 3.5868e-05 |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.09
Other   |            | 0.006047   |            |       |  0.01

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

Total # of neighbors = 322398
Ave neighs/atom = 161.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 = 332.897323203648, Press = -0.0366124734938047
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -10429.186     -10429.186     -10510.795     -10510.795      315.83642      315.83642      28075.562      28075.562     -647.07443     -647.07443    
    138000  -10422.604     -10422.604     -10508.141     -10508.141      331.03727      331.03727      28121.963      28121.963     -2815.0006     -2815.0006    
Loop time of 69.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.249 ns/day, 19.216 hours/ns, 14.455 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.091     | 69.091     | 69.091     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019207   | 0.019207   | 0.019207   |   0.0 |  0.03
Output  | 3.2682e-05 | 3.2682e-05 | 3.2682e-05 |   0.0 |  0.00
Modify  | 0.06178    | 0.06178    | 0.06178    |   0.0 |  0.09
Other   |            | 0.006015   |            |       |  0.01

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

Total # of neighbors = 323150
Ave neighs/atom = 161.575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.899148748943, Press = 0.128696280553777
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -10422.604     -10422.604     -10508.141     -10508.141      331.03727      331.03727      28121.963      28121.963     -2815.0006     -2815.0006    
    139000  -10418.789     -10418.789     -10504.898     -10504.898      333.25033      333.25033      28110.703      28110.703     -1631.5767     -1631.5767    
Loop time of 68.9941 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.252 ns/day, 19.165 hours/ns, 14.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 68.907     | 68.907     | 68.907     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019218   | 0.019218   | 0.019218   |   0.0 |  0.03
Output  | 3.2892e-05 | 3.2892e-05 | 3.2892e-05 |   0.0 |  0.00
Modify  | 0.061654   | 0.061654   | 0.061654   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

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

Total # of neighbors = 322026
Ave neighs/atom = 161.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.906033372711, Press = 0.510152060650022
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -10418.789     -10418.789     -10504.898     -10504.898      333.25033      333.25033      28110.703      28110.703     -1631.5767     -1631.5767    
    140000  -10422.952     -10422.952     -10509.49      -10509.49       334.91228      334.91228      28080.655      28080.655     -523.17543     -523.17543    
Loop time of 69.1197 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.200 hours/ns, 14.468 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    | 69.033     | 69.033     | 69.033     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019235   | 0.019235   | 0.019235   |   0.0 |  0.03
Output  | 3.3363e-05 | 3.3363e-05 | 3.3363e-05 |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.09
Other   |            | 0.006019   |            |       |  0.01

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

Total # of neighbors = 322078
Ave neighs/atom = 161.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.931394047682, Press = 0.220322199130314
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -10422.952     -10422.952     -10509.49      -10509.49       334.91228      334.91228      28080.655      28080.655     -523.17543     -523.17543    
    141000  -10422.575     -10422.575     -10510.559     -10510.559      340.50958      340.50958      28070.659      28070.659     -94.211059     -94.211059    
Loop time of 69.2884 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.247 ns/day, 19.247 hours/ns, 14.432 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.201     | 69.201     | 69.201     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019324   | 0.019324   | 0.019324   |   0.0 |  0.03
Output  | 3.3664e-05 | 3.3664e-05 | 3.3664e-05 |   0.0 |  0.00
Modify  | 0.061701   | 0.061701   | 0.061701   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

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

Total # of neighbors = 323200
Ave neighs/atom = 161.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.93740387306, Press = 0.218749753129581
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -10422.575     -10422.575     -10510.559     -10510.559      340.50958      340.50958      28070.659      28070.659     -94.211059     -94.211059    
    142000  -10424.197     -10424.197     -10511.496     -10511.496      337.85726      337.85726      28055.197      28055.197      694.56528      694.56528    
Loop time of 69.3781 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.272 hours/ns, 14.414 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.291     | 69.291     | 69.291     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019237   | 0.019237   | 0.019237   |   0.0 |  0.03
Output  | 3.0939e-05 | 3.0939e-05 | 3.0939e-05 |   0.0 |  0.00
Modify  | 0.061662   | 0.061662   | 0.061662   |   0.0 |  0.09
Other   |            | 0.00604    |            |       |  0.01

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

Total # of neighbors = 323052
Ave neighs/atom = 161.526
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942918506061, Press = 0.17386357470219
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -10424.197     -10424.197     -10511.496     -10511.496      337.85726      337.85726      28055.197      28055.197      694.56528      694.56528    
    143000  -10418.142     -10418.142     -10506.347     -10506.347      341.364        341.364        28030.27       28030.27       2606.6727      2606.6727    
Loop time of 69.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.225 hours/ns, 14.449 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.124     | 69.124     | 69.124     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019232   | 0.019232   | 0.019232   |   0.0 |  0.03
Output  | 3.4745e-05 | 3.4745e-05 | 3.4745e-05 |   0.0 |  0.00
Modify  | 0.061713   | 0.061713   | 0.061713   |   0.0 |  0.09
Other   |            | 0.006029   |            |       |  0.01

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

Total # of neighbors = 323222
Ave neighs/atom = 161.611
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.963276393211, Press = 0.483206745173502
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -10418.142     -10418.142     -10506.347     -10506.347      341.364        341.364        28030.27       28030.27       2606.6727      2606.6727    
    144000  -10423.465     -10423.465     -10509.64      -10509.64       333.50502      333.50502      28003.092      28003.092      3510.1761      3510.1761    
Loop time of 69.1444 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.250 ns/day, 19.207 hours/ns, 14.462 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    | 69.057     | 69.057     | 69.057     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019307   | 0.019307   | 0.019307   |   0.0 |  0.03
Output  | 3.6328e-05 | 3.6328e-05 | 3.6328e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.09
Other   |            | 0.006043   |            |       |  0.01

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

Total # of neighbors = 323154
Ave neighs/atom = 161.577
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978670324425, Press = 0.234912800134884
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -10423.465     -10423.465     -10509.64      -10509.64       333.50502      333.50502      28003.092      28003.092      3510.1761      3510.1761    
    145000  -10421.516     -10421.516     -10508.928     -10508.928      338.29055      338.29055      28036.79       28036.79       1769.5974      1769.5974    
Loop time of 69.2335 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.248 ns/day, 19.232 hours/ns, 14.444 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.146     | 69.146     | 69.146     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019254   | 0.019254   | 0.019254   |   0.0 |  0.03
Output  | 3.163e-05  | 3.163e-05  | 3.163e-05  |   0.0 |  0.00
Modify  | 0.061671   | 0.061671   | 0.061671   |   0.0 |  0.09
Other   |            | 0.006053   |            |       |  0.01

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0