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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.620386697351933*${_u_distance}
variable latticeconst_converted equal 3.620386697351933*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62038669735193
Lattice spacing in x,y,z = 3.6203867 3.6203867 3.6203867
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.203867 36.203867 36.203867)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.203867 36.203867 36.203867)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Cu

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

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


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

variable temp_converted equal 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_390178379548_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13987.791     -13987.791     -14160         -14160          333.15         333.15         47453.132      47453.132      3876.2527      3876.2527    
      1000  -13802.779     -13802.779     -13981.589     -13981.589      345.92139      345.92139      48215.763      48215.763     -369.01557     -369.01557    
Loop time of 204.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.800 hours/ns, 4.890 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.53     | 203.53     | 203.53     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15152    | 0.15152    | 0.15152    |   0.0 |  0.07
Output  | 0.00028371 | 0.00028371 | 0.00028371 |   0.0 |  0.00
Modify  | 0.7035     | 0.7035     | 0.7035     |   0.0 |  0.34
Other   |            | 0.09924    |            |       |  0.05

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13802.779     -13802.779     -13981.589     -13981.589      345.92139      345.92139      48215.763      48215.763     -369.01557     -369.01557    
      2000  -13816.772     -13816.772     -13991.093     -13991.093      337.23749      337.23749      48223.335      48223.335     -1272.6478     -1272.6478    
Loop time of 205.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.164 hours/ns, 4.859 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.89     | 204.89     | 204.89     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14658    | 0.14658    | 0.14658    |   0.0 |  0.07
Output  | 0.00027062 | 0.00027062 | 0.00027062 |   0.0 |  0.00
Modify  | 0.65925    | 0.65925    | 0.65925    |   0.0 |  0.32
Other   |            | 0.096      |            |       |  0.05

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

Total # of neighbors = 310138
Ave neighs/atom = 77.5345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13816.772     -13816.772     -13991.093     -13991.093      337.23749      337.23749      48223.335      48223.335     -1272.6478     -1272.6478    
      3000  -13809.729     -13809.729     -13985.164     -13985.164      339.39047      339.39047      48193.882      48193.882      218.58526      218.58526    
Loop time of 221.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.639 hours/ns, 4.507 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.91     | 220.91     | 220.91     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15479    | 0.15479    | 0.15479    |   0.0 |  0.07
Output  | 0.00023041 | 0.00023041 | 0.00023041 |   0.0 |  0.00
Modify  | 0.73114    | 0.73114    | 0.73114    |   0.0 |  0.33
Other   |            | 0.1021     |            |       |  0.05

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

Total # of neighbors = 310470
Ave neighs/atom = 77.6175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13809.729     -13809.729     -13985.164     -13985.164      339.39047      339.39047      48193.882      48193.882      218.58526      218.58526    
      4000  -13814.927     -13814.927     -13987.724     -13987.724      334.28798      334.28798      48175.532      48175.532      465.49831      465.49831    
Loop time of 202.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.252 hours/ns, 4.938 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.62     | 201.62     | 201.62     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14684    | 0.14684    | 0.14684    |   0.0 |  0.07
Output  | 0.00023466 | 0.00023466 | 0.00023466 |   0.0 |  0.00
Modify  | 0.64589    | 0.64589    | 0.64589    |   0.0 |  0.32
Other   |            | 0.09371    |            |       |  0.05

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

Total # of neighbors = 310350
Ave neighs/atom = 77.5875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13814.927     -13814.927     -13987.724     -13987.724      334.28798      334.28798      48175.532      48175.532      465.49831      465.49831    
      5000  -13812.847     -13812.847     -13989.721     -13989.721      342.17388      342.17388      48218.834      48218.834     -981.21152     -981.21152    
Loop time of 202.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.330 hours/ns, 4.931 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.9      | 201.9      | 201.9      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14901    | 0.14901    | 0.14901    |   0.0 |  0.07
Output  | 0.00023029 | 0.00023029 | 0.00023029 |   0.0 |  0.00
Modify  | 0.64879    | 0.64879    | 0.64879    |   0.0 |  0.32
Other   |            | 0.09351    |            |       |  0.05

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

Total # of neighbors = 310428
Ave neighs/atom = 77.607
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 336.898193007873, Press = 213.218983009432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13812.847     -13812.847     -13989.721     -13989.721      342.17388      342.17388      48218.834      48218.834     -981.21152     -981.21152    
      6000  -13811.114     -13811.114     -13984.959     -13984.959      336.31496      336.31496      48239.394      48239.394     -1006.4319     -1006.4319    
Loop time of 203.145 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.429 hours/ns, 4.923 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.23     | 202.23     | 202.23     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15049    | 0.15049    | 0.15049    |   0.0 |  0.07
Output  | 0.00023129 | 0.00023129 | 0.00023129 |   0.0 |  0.00
Modify  | 0.67433    | 0.67433    | 0.67433    |   0.0 |  0.33
Other   |            | 0.09351    |            |       |  0.05

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

Total # of neighbors = 310284
Ave neighs/atom = 77.571
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.521320307297, Press = 4.96083619239322
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13811.114     -13811.114     -13984.959     -13984.959      336.31496      336.31496      48239.394      48239.394     -1006.4319     -1006.4319    
      7000  -13817.264     -13817.264     -13985.396     -13985.396      325.26202      325.26202      48162.954      48162.954      888.04472      888.04472    
Loop time of 224.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.420 hours/ns, 4.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    | 223.68     | 223.68     | 223.68     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15709    | 0.15709    | 0.15709    |   0.0 |  0.07
Output  | 0.00019406 | 0.00019406 | 0.00019406 |   0.0 |  0.00
Modify  | 0.77588    | 0.77588    | 0.77588    |   0.0 |  0.35
Other   |            | 0.1029     |            |       |  0.05

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

Total # of neighbors = 310344
Ave neighs/atom = 77.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.086536997471, Press = -18.1370599305946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13817.264     -13817.264     -13985.396     -13985.396      325.26202      325.26202      48162.954      48162.954      888.04472      888.04472    
      8000  -13810.952     -13810.952     -13985.288     -13985.288      337.26464      337.26464      48109.988      48109.988      2628.9447      2628.9447    
Loop time of 201.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.007 hours/ns, 4.960 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.72     | 200.72     | 200.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1452     | 0.1452     | 0.1452     |   0.0 |  0.07
Output  | 0.00019169 | 0.00019169 | 0.00019169 |   0.0 |  0.00
Modify  | 0.66934    | 0.66934    | 0.66934    |   0.0 |  0.33
Other   |            | 0.09494    |            |       |  0.05

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

Total # of neighbors = 310470
Ave neighs/atom = 77.6175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.268598115399, Press = 13.5256592876572
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13810.952     -13810.952     -13985.288     -13985.288      337.26464      337.26464      48109.988      48109.988      2628.9447      2628.9447    
      9000  -13809.764     -13809.764     -13981.483     -13981.483      332.20314      332.20314      48207.253      48207.253     -13.389149     -13.389149    
Loop time of 202.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.256 hours/ns, 4.938 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.61     | 201.61     | 201.61     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14511    | 0.14511    | 0.14511    |   0.0 |  0.07
Output  | 0.00026474 | 0.00026474 | 0.00026474 |   0.0 |  0.00
Modify  | 0.67199    | 0.67199    | 0.67199    |   0.0 |  0.33
Other   |            | 0.09609    |            |       |  0.05

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

Total # of neighbors = 310462
Ave neighs/atom = 77.6155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.464073294053, Press = 16.634011539462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13809.764     -13809.764     -13981.483     -13981.483      332.20314      332.20314      48207.253      48207.253     -13.389149     -13.389149    
     10000  -13816.055     -13816.055     -13987.537     -13987.537      331.74494      331.74494      48236.625      48236.625     -1325.0581     -1325.0581    
Loop time of 239.007 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.361 ns/day, 66.391 hours/ns, 4.184 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    | 237.91     | 237.91     | 237.91     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16447    | 0.16447    | 0.16447    |   0.0 |  0.07
Output  | 0.00018812 | 0.00018812 | 0.00018812 |   0.0 |  0.00
Modify  | 0.82286    | 0.82286    | 0.82286    |   0.0 |  0.34
Other   |            | 0.1073     |            |       |  0.04

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

Total # of neighbors = 310116
Ave neighs/atom = 77.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.699887767872, Press = 5.04590350339446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13816.055     -13816.055     -13987.537     -13987.537      331.74494      331.74494      48236.625      48236.625     -1325.0581     -1325.0581    
     11000  -13815.113     -13815.113     -13985.542     -13985.542      329.70627      329.70627      48214.35       48214.35      -585.37945     -585.37945    
Loop time of 238.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.204 hours/ns, 4.196 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    | 237.23     | 237.23     | 237.23     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16467    | 0.16467    | 0.16467    |   0.0 |  0.07
Output  | 0.00018815 | 0.00018815 | 0.00018815 |   0.0 |  0.00
Modify  | 0.83311    | 0.83311    | 0.83311    |   0.0 |  0.35
Other   |            | 0.1082     |            |       |  0.05

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

Total # of neighbors = 310434
Ave neighs/atom = 77.6085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.64442707639, Press = -2.19944382096125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13815.113     -13815.113     -13985.542     -13985.542      329.70627      329.70627      48214.35       48214.35      -585.37945     -585.37945    
     12000  -13813.771     -13813.771     -13988.341     -13988.341      337.71742      337.71742      48177.862      48177.862      349.54209      349.54209    
Loop time of 234.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.033 hours/ns, 4.271 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.04     | 233.04     | 233.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1605     | 0.1605     | 0.1605     |   0.0 |  0.07
Output  | 0.00019124 | 0.00019124 | 0.00019124 |   0.0 |  0.00
Modify  | 0.814      | 0.814      | 0.814      |   0.0 |  0.35
Other   |            | 0.1061     |            |       |  0.05

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

Total # of neighbors = 310330
Ave neighs/atom = 77.5825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.163652287276, Press = -0.749028670947212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13813.771     -13813.771     -13988.341     -13988.341      337.71742      337.71742      48177.862      48177.862      349.54209      349.54209    
     13000  -13813.693     -13813.693     -13985.325     -13985.325      332.03339      332.03339      48166.885      48166.885      802.5087       802.5087     
Loop time of 231.574 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.326 hours/ns, 4.318 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    | 230.51     | 230.51     | 230.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16087    | 0.16087    | 0.16087    |   0.0 |  0.07
Output  | 0.00019108 | 0.00019108 | 0.00019108 |   0.0 |  0.00
Modify  | 0.80147    | 0.80147    | 0.80147    |   0.0 |  0.35
Other   |            | 0.1043     |            |       |  0.05

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

Total # of neighbors = 310472
Ave neighs/atom = 77.618
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.291240544803, Press = 3.60018441429225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13813.693     -13813.693     -13985.325     -13985.325      332.03339      332.03339      48166.885      48166.885      802.5087       802.5087     
     14000  -13815.544     -13815.544     -13985.739     -13985.739      329.25417      329.25417      48199.04       48199.04      -144.5086      -144.5086     
Loop time of 202.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.140 hours/ns, 4.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.2      | 201.2      | 201.2      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14639    | 0.14639    | 0.14639    |   0.0 |  0.07
Output  | 0.000467   | 0.000467   | 0.000467   |   0.0 |  0.00
Modify  | 0.66868    | 0.66868    | 0.66868    |   0.0 |  0.33
Other   |            | 0.09343    |            |       |  0.05

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

Total # of neighbors = 310330
Ave neighs/atom = 77.5825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.182738108745, Press = 3.7550962922045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13815.544     -13815.544     -13985.739     -13985.739      329.25417      329.25417      48199.04       48199.04      -144.5086      -144.5086     
     15000  -13805.917     -13805.917     -13979.077     -13979.077      334.98867      334.98867      48262.1        48262.1       -1271.1879     -1271.1879    
Loop time of 202.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.125 hours/ns, 4.949 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.14     | 201.14     | 201.14     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14644    | 0.14644    | 0.14644    |   0.0 |  0.07
Output  | 0.00019045 | 0.00019045 | 0.00019045 |   0.0 |  0.00
Modify  | 0.66861    | 0.66861    | 0.66861    |   0.0 |  0.33
Other   |            | 0.09355    |            |       |  0.05

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

Total # of neighbors = 310324
Ave neighs/atom = 77.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 = 333.325961879675, Press = -0.719256785938633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13805.917     -13805.917     -13979.077     -13979.077      334.98867      334.98867      48262.1        48262.1       -1271.1879     -1271.1879    
     16000  -13813.369     -13813.369     -13984.881     -13984.881      331.80197      331.80197      48203.216      48203.216     -101.71802     -101.71802    
Loop time of 204.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.728 hours/ns, 4.897 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.3      | 203.3      | 203.3      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1478     | 0.1478     | 0.1478     |   0.0 |  0.07
Output  | 0.00023214 | 0.00023214 | 0.00023214 |   0.0 |  0.00
Modify  | 0.68163    | 0.68163    | 0.68163    |   0.0 |  0.33
Other   |            | 0.09571    |            |       |  0.05

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

Total # of neighbors = 309946
Ave neighs/atom = 77.4865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.377417261747, Press = -4.08470928837378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13813.369     -13813.369     -13984.881     -13984.881      331.80197      331.80197      48203.216      48203.216     -101.71802     -101.71802    
     17000  -13806.602     -13806.602     -13982.313     -13982.313      339.92497      339.92497      48136.112      48136.112      2176.8458      2176.8458    
Loop time of 202.226 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.174 hours/ns, 4.945 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.31     | 201.31     | 201.31     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1463     | 0.1463     | 0.1463     |   0.0 |  0.07
Output  | 0.00019347 | 0.00019347 | 0.00019347 |   0.0 |  0.00
Modify  | 0.67203    | 0.67203    | 0.67203    |   0.0 |  0.33
Other   |            | 0.09511    |            |       |  0.05

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

Total # of neighbors = 310450
Ave neighs/atom = 77.6125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.546479889837, Press = -1.6811117474139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13806.602     -13806.602     -13982.313     -13982.313      339.92497      339.92497      48136.112      48136.112      2176.8458      2176.8458    
     18000  -13814.601     -13814.601     -13986.959     -13986.959      333.43706      333.43706      48166.803      48166.803      719.84553      719.84553    
Loop time of 202.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.137 hours/ns, 4.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.18     | 201.18     | 201.18     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14614    | 0.14614    | 0.14614    |   0.0 |  0.07
Output  | 0.0002652  | 0.0002652  | 0.0002652  |   0.0 |  0.00
Modify  | 0.67199    | 0.67199    | 0.67199    |   0.0 |  0.33
Other   |            | 0.09405    |            |       |  0.05

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

Total # of neighbors = 310370
Ave neighs/atom = 77.5925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.633260835924, Press = 3.3176140400659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13814.601     -13814.601     -13986.959     -13986.959      333.43706      333.43706      48166.803      48166.803      719.84553      719.84553    
     19000  -13814.079     -13814.079     -13982.521     -13982.521      325.86364      325.86364      48193.03       48193.03       407.62094      407.62094    
Loop time of 202.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.278 hours/ns, 4.936 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.69     | 201.69     | 201.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1475     | 0.1475     | 0.1475     |   0.0 |  0.07
Output  | 0.00023469 | 0.00023469 | 0.00023469 |   0.0 |  0.00
Modify  | 0.67226    | 0.67226    | 0.67226    |   0.0 |  0.33
Other   |            | 0.09381    |            |       |  0.05

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

Total # of neighbors = 310392
Ave neighs/atom = 77.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 = 333.648002531805, Press = 2.97766334168583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13814.079     -13814.079     -13982.521     -13982.521      325.86364      325.86364      48193.03       48193.03       407.62094      407.62094    
     20000  -13811.324     -13811.324     -13985.507     -13985.507      336.96882      336.96882      48241.559      48241.559     -1170.7516     -1170.7516    
Loop time of 220.048 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.125 hours/ns, 4.544 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.04     | 219.04     | 219.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15456    | 0.15456    | 0.15456    |   0.0 |  0.07
Output  | 0.00025005 | 0.00025005 | 0.00025005 |   0.0 |  0.00
Modify  | 0.75069    | 0.75069    | 0.75069    |   0.0 |  0.34
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 310292
Ave neighs/atom = 77.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.672076378084, Press = 0.429152038833704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13811.324     -13811.324     -13985.507     -13985.507      336.96882      336.96882      48241.559      48241.559     -1170.7516     -1170.7516    
     21000  -13811.197     -13811.197     -13983.844     -13983.844      333.9974       333.9974       48216.282      48216.282     -407.3005      -407.3005     
Loop time of 237.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.847 hours/ns, 4.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.94     | 235.94     | 235.94     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16498    | 0.16498    | 0.16498    |   0.0 |  0.07
Output  | 0.00019475 | 0.00019475 | 0.00019475 |   0.0 |  0.00
Modify  | 0.83767    | 0.83767    | 0.83767    |   0.0 |  0.35
Other   |            | 0.1077     |            |       |  0.05

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

Total # of neighbors = 310312
Ave neighs/atom = 77.578
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.769248063681, Press = -1.42589536396574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13811.197     -13811.197     -13983.844     -13983.844      333.9974       333.9974       48216.282      48216.282     -407.3005      -407.3005     
     22000  -13811.661     -13811.661     -13982.396     -13982.396      330.29947      330.29947      48156.271      48156.271      1407.0773      1407.0773    
Loop time of 237.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.992 hours/ns, 4.209 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    | 236.47     | 236.47     | 236.47     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16387    | 0.16387    | 0.16387    |   0.0 |  0.07
Output  | 0.00019406 | 0.00019406 | 0.00019406 |   0.0 |  0.00
Modify  | 0.82947    | 0.82947    | 0.82947    |   0.0 |  0.35
Other   |            | 0.106      |            |       |  0.04

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

Total # of neighbors = 310258
Ave neighs/atom = 77.5645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.632173260545, Press = -1.90505682493068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13811.661     -13811.661     -13982.396     -13982.396      330.29947      330.29947      48156.271      48156.271      1407.0773      1407.0773    
     23000  -13816.378     -13816.378     -13989.389     -13989.389      334.70176      334.70176      48095.969      48095.969      2570.7628      2570.7628    
Loop time of 238.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.362 ns/day, 66.221 hours/ns, 4.195 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    | 237.29     | 237.29     | 237.29     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16662    | 0.16662    | 0.16662    |   0.0 |  0.07
Output  | 0.00019427 | 0.00019427 | 0.00019427 |   0.0 |  0.00
Modify  | 0.83169    | 0.83169    | 0.83169    |   0.0 |  0.35
Other   |            | 0.1067     |            |       |  0.04

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

Total # of neighbors = 310272
Ave neighs/atom = 77.568
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.559327176215, Press = 3.3650855721944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13816.378     -13816.378     -13989.389     -13989.389      334.70176      334.70176      48095.969      48095.969      2570.7628      2570.7628    
     24000  -13814.572     -13814.572     -13987.259     -13987.259      334.07439      334.07439      48211.992      48211.992     -548.4965      -548.4965     
Loop time of 219.829 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.064 hours/ns, 4.549 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    | 218.83     | 218.83     | 218.83     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15501    | 0.15501    | 0.15501    |   0.0 |  0.07
Output  | 0.00023231 | 0.00023231 | 0.00023231 |   0.0 |  0.00
Modify  | 0.7472     | 0.7472     | 0.7472     |   0.0 |  0.34
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 310658
Ave neighs/atom = 77.6645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.41064056042, Press = 6.24254710361182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13814.572     -13814.572     -13987.259     -13987.259      334.07439      334.07439      48211.992      48211.992     -548.4965      -548.4965     
     25000  -13815.316     -13815.316     -13985.489     -13985.489      329.2111       329.2111       48231.97       48231.97      -995.28635     -995.28635    
Loop time of 201.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.032 hours/ns, 4.957 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.81     | 200.81     | 200.81     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14452    | 0.14452    | 0.14452    |   0.0 |  0.07
Output  | 0.00023265 | 0.00023265 | 0.00023265 |   0.0 |  0.00
Modify  | 0.66759    | 0.66759    | 0.66759    |   0.0 |  0.33
Other   |            | 0.09339    |            |       |  0.05

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

Total # of neighbors = 310436
Ave neighs/atom = 77.609
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.39186535963, Press = 0.661537804191081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13815.316     -13815.316     -13985.489     -13985.489      329.2111       329.2111       48231.97       48231.97      -995.28635     -995.28635    
     26000  -13808.044     -13808.044     -13983.476     -13983.476      339.38545      339.38545      48216.607      48216.607     -169.24868     -169.24868    
Loop time of 200.824 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.785 hours/ns, 4.979 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.92     | 199.92     | 199.92     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14276    | 0.14276    | 0.14276    |   0.0 |  0.07
Output  | 0.00019123 | 0.00019123 | 0.00019123 |   0.0 |  0.00
Modify  | 0.66524    | 0.66524    | 0.66524    |   0.0 |  0.33
Other   |            | 0.09534    |            |       |  0.05

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

Total # of neighbors = 310448
Ave neighs/atom = 77.612
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.334770544277, Press = -0.250853563610498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13808.044     -13808.044     -13983.476     -13983.476      339.38545      339.38545      48216.607      48216.607     -169.24868     -169.24868    
     27000  -13813.017     -13813.017     -13985.212     -13985.212      333.12368      333.12368      48183.224      48183.224      517.94847      517.94847    
Loop time of 201.297 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.916 hours/ns, 4.968 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.39     | 200.39     | 200.39     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.07
Output  | 0.00019064 | 0.00019064 | 0.00019064 |   0.0 |  0.00
Modify  | 0.6666     | 0.6666     | 0.6666     |   0.0 |  0.33
Other   |            | 0.09559    |            |       |  0.05

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

Total # of neighbors = 310382
Ave neighs/atom = 77.5955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.3320828363, Press = 0.435202477700931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13813.017     -13813.017     -13985.212     -13985.212      333.12368      333.12368      48183.224      48183.224      517.94847      517.94847    
     28000  -13811.577     -13811.577     -13983.582     -13983.582      332.7565       332.7565       48161.268      48161.268      1320.0876      1320.0876    
Loop time of 201.932 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.092 hours/ns, 4.952 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.02     | 201.02     | 201.02     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14558    | 0.14558    | 0.14558    |   0.0 |  0.07
Output  | 0.00019384 | 0.00019384 | 0.00019384 |   0.0 |  0.00
Modify  | 0.66869    | 0.66869    | 0.66869    |   0.0 |  0.33
Other   |            | 0.09493    |            |       |  0.05

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

Total # of neighbors = 310490
Ave neighs/atom = 77.6225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.330227622607, Press = 2.3806276874504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13811.577     -13811.577     -13983.582     -13983.582      332.7565       332.7565       48161.268      48161.268      1320.0876      1320.0876    
     29000  -13815.894     -13815.894     -13985.811     -13985.811      328.71679      328.71679      48244.36       48244.36      -1434.9923     -1434.9923    
Loop time of 207.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.603 hours/ns, 4.822 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    | 206.43     | 206.43     | 206.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14859    | 0.14859    | 0.14859    |   0.0 |  0.07
Output  | 0.00028652 | 0.00028652 | 0.00028652 |   0.0 |  0.00
Modify  | 0.69896    | 0.69896    | 0.69896    |   0.0 |  0.34
Other   |            | 0.09793    |            |       |  0.05

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

Total # of neighbors = 310428
Ave neighs/atom = 77.607
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.337599003644, Press = 3.47983503329493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13815.894     -13815.894     -13985.811     -13985.811      328.71679      328.71679      48244.36       48244.36      -1434.9923     -1434.9923    
     30000  -13811.979     -13811.979     -13984.809     -13984.809      334.3519       334.3519       48268.851      48268.851     -1888.352      -1888.352     
Loop time of 237.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.097 hours/ns, 4.203 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    | 236.85     | 236.85     | 236.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16329    | 0.16329    | 0.16329    |   0.0 |  0.07
Output  | 0.00019446 | 0.00019446 | 0.00019446 |   0.0 |  0.00
Modify  | 0.82384    | 0.82384    | 0.82384    |   0.0 |  0.35
Other   |            | 0.108      |            |       |  0.05

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

Total # of neighbors = 310254
Ave neighs/atom = 77.5635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.399875622282, Press = -0.297667896999174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13811.979     -13811.979     -13984.809     -13984.809      334.3519       334.3519       48268.851      48268.851     -1888.352      -1888.352     
     31000  -13810.829     -13810.829     -13981.977     -13981.977      331.09821      331.09821      48195.348      48195.348      284.13274      284.13274    
Loop time of 238.113 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.143 hours/ns, 4.200 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    | 237.03     | 237.03     | 237.03     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16239    | 0.16239    | 0.16239    |   0.0 |  0.07
Output  | 0.00019451 | 0.00019451 | 0.00019451 |   0.0 |  0.00
Modify  | 0.81139    | 0.81139    | 0.81139    |   0.0 |  0.34
Other   |            | 0.1071     |            |       |  0.04

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

Total # of neighbors = 310236
Ave neighs/atom = 77.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.420935824821, Press = -1.06124604922491
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13810.829     -13810.829     -13981.977     -13981.977      331.09821      331.09821      48195.348      48195.348      284.13274      284.13274    
     32000  -13818.171     -13818.171     -13988.514     -13988.514      329.53991      329.53991      48137.127      48137.127      1442.9046      1442.9046    
Loop time of 235.843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.512 hours/ns, 4.240 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    | 234.74     | 234.74     | 234.74     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16259    | 0.16259    | 0.16259    |   0.0 |  0.07
Output  | 0.00024101 | 0.00024101 | 0.00024101 |   0.0 |  0.00
Modify  | 0.82882    | 0.82882    | 0.82882    |   0.0 |  0.35
Other   |            | 0.1082     |            |       |  0.05

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

Total # of neighbors = 310154
Ave neighs/atom = 77.5385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.436514710887, Press = 0.779491629913461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13818.171     -13818.171     -13988.514     -13988.514      329.53991      329.53991      48137.127      48137.127      1442.9046      1442.9046    
     33000  -13812.247     -13812.247     -13985.91      -13985.91       335.96249      335.96249      48190.643      48190.643      220.72367      220.72367    
Loop time of 236.6 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.722 hours/ns, 4.227 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.51     | 235.51     | 235.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16323    | 0.16323    | 0.16323    |   0.0 |  0.07
Output  | 0.00019433 | 0.00019433 | 0.00019433 |   0.0 |  0.00
Modify  | 0.82258    | 0.82258    | 0.82258    |   0.0 |  0.35
Other   |            | 0.1069     |            |       |  0.05

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

Total # of neighbors = 310606
Ave neighs/atom = 77.6515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.405143419863, Press = 2.55285593793108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13812.247     -13812.247     -13985.91      -13985.91       335.96249      335.96249      48190.643      48190.643      220.72367      220.72367    
     34000  -13816.411     -13816.411     -13987.681     -13987.681      331.3333       331.3333       48251.205      48251.205     -1771.3675     -1771.3675    
Loop time of 236.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.679 hours/ns, 4.229 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.34     | 235.34     | 235.34     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16504    | 0.16504    | 0.16504    |   0.0 |  0.07
Output  | 0.00029988 | 0.00029988 | 0.00029988 |   0.0 |  0.00
Modify  | 0.82971    | 0.82971    | 0.82971    |   0.0 |  0.35
Other   |            | 0.1078     |            |       |  0.05

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

Total # of neighbors = 310438
Ave neighs/atom = 77.6095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.345446161694, Press = 1.0882343672234
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13816.411     -13816.411     -13987.681     -13987.681      331.3333       331.3333       48251.205      48251.205     -1771.3675     -1771.3675    
     35000  -13814.589     -13814.589     -13984.466     -13984.466      328.63714      328.63714      48220.763      48220.763     -646.34909     -646.34909    
Loop time of 236.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.733 hours/ns, 4.226 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.53     | 235.53     | 235.53     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16512    | 0.16512    | 0.16512    |   0.0 |  0.07
Output  | 0.00027033 | 0.00027033 | 0.00027033 |   0.0 |  0.00
Modify  | 0.83094    | 0.83094    | 0.83094    |   0.0 |  0.35
Other   |            | 0.1079     |            |       |  0.05

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

Total # of neighbors = 310290
Ave neighs/atom = 77.5725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.314006535776, Press = -1.59698247258349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13814.589     -13814.589     -13984.466     -13984.466      328.63714      328.63714      48220.763      48220.763     -646.34909     -646.34909    
     36000  -13807.73      -13807.73      -13983.318     -13983.318      339.68703      339.68703      48125.255      48125.255      2478.7837      2478.7837    
Loop time of 236.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.815 hours/ns, 4.221 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.83     | 235.83     | 235.83     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16546    | 0.16546    | 0.16546    |   0.0 |  0.07
Output  | 0.00027078 | 0.00027078 | 0.00027078 |   0.0 |  0.00
Modify  | 0.83292    | 0.83292    | 0.83292    |   0.0 |  0.35
Other   |            | 0.1077     |            |       |  0.05

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

Total # of neighbors = 310370
Ave neighs/atom = 77.5925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.284466448199, Press = -0.477826450622554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13807.73      -13807.73      -13983.318     -13983.318      339.68703      339.68703      48125.255      48125.255      2478.7837      2478.7837    
     37000  -13816.004     -13816.004     -13987.18      -13987.18       331.15117      331.15117      48156.428      48156.428      993.22861      993.22861    
Loop time of 237.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.095 hours/ns, 4.203 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    | 236.85     | 236.85     | 236.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16419    | 0.16419    | 0.16419    |   0.0 |  0.07
Output  | 0.00028265 | 0.00028265 | 0.00028265 |   0.0 |  0.00
Modify  | 0.82525    | 0.82525    | 0.82525    |   0.0 |  0.35
Other   |            | 0.1057     |            |       |  0.04

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

Total # of neighbors = 310542
Ave neighs/atom = 77.6355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.312136446949, Press = 1.84223769822816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13816.004     -13816.004     -13987.18      -13987.18       331.15117      331.15117      48156.428      48156.428      993.22861      993.22861    
     38000  -13812.541     -13812.541     -13981.637     -13981.637      327.12736      327.12736      48218.181      48218.181     -224.32246     -224.32246    
Loop time of 237.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.096 hours/ns, 4.203 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    | 236.82     | 236.82     | 236.82     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16637    | 0.16637    | 0.16637    |   0.0 |  0.07
Output  | 0.00019288 | 0.00019288 | 0.00019288 |   0.0 |  0.00
Modify  | 0.84893    | 0.84893    | 0.84893    |   0.0 |  0.36
Other   |            | 0.1079     |            |       |  0.05

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

Total # of neighbors = 310552
Ave neighs/atom = 77.638
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.31913966695, Press = 1.70119238882762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13812.541     -13812.541     -13981.637     -13981.637      327.12736      327.12736      48218.181      48218.181     -224.32246     -224.32246    
     39000  -13815.406     -13815.406     -13985.385     -13985.385      328.83755      328.83755      48230.61       48230.61      -961.27776     -961.27776    
Loop time of 213.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.332 hours/ns, 4.682 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.63     | 212.63     | 212.63     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1521     | 0.1521     | 0.1521     |   0.0 |  0.07
Output  | 0.00023596 | 0.00023596 | 0.00023596 |   0.0 |  0.00
Modify  | 0.71774    | 0.71774    | 0.71774    |   0.0 |  0.34
Other   |            | 0.09635    |            |       |  0.05

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

Total # of neighbors = 310280
Ave neighs/atom = 77.57
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.265427470619, Press = 0.349824100396523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13815.406     -13815.406     -13985.385     -13985.385      328.83755      328.83755      48230.61       48230.61      -961.27776     -961.27776    
     40000  -13812.421     -13812.421     -13984.247     -13984.247      332.40873      332.40873      48189.602      48189.602      388.81707      388.81707    
Loop time of 204.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.910 hours/ns, 4.881 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.95     | 203.95     | 203.95     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14738    | 0.14738    | 0.14738    |   0.0 |  0.07
Output  | 0.00023401 | 0.00023401 | 0.00023401 |   0.0 |  0.00
Modify  | 0.68342    | 0.68342    | 0.68342    |   0.0 |  0.33
Other   |            | 0.09515    |            |       |  0.05

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

Total # of neighbors = 310238
Ave neighs/atom = 77.5595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.229192797798, Press = -0.255658147597784
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13812.421     -13812.421     -13984.247     -13984.247      332.40873      332.40873      48189.602      48189.602      388.81707      388.81707    
     41000  -13812.699     -13812.699     -13984.672     -13984.672      332.69205      332.69205      48080.879      48080.879      3430.7107      3430.7107    
Loop time of 238.032 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.363 ns/day, 66.120 hours/ns, 4.201 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    | 236.92     | 236.92     | 236.92     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16643    | 0.16643    | 0.16643    |   0.0 |  0.07
Output  | 0.00019663 | 0.00019663 | 0.00019663 |   0.0 |  0.00
Modify  | 0.83663    | 0.83663    | 0.83663    |   0.0 |  0.35
Other   |            | 0.1073     |            |       |  0.05

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

Total # of neighbors = 310338
Ave neighs/atom = 77.5845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.174565929752, Press = 2.03339070234999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13812.699     -13812.699     -13984.672     -13984.672      332.69205      332.69205      48080.879      48080.879      3430.7107      3430.7107    
     42000  -13815.545     -13815.545     -13986.44      -13986.44       330.60969      330.60969      48204.898      48204.898     -376.16171     -376.16171    
Loop time of 237.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.913 hours/ns, 4.214 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    | 236.18     | 236.18     | 236.18     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16721    | 0.16721    | 0.16721    |   0.0 |  0.07
Output  | 0.00019248 | 0.00019248 | 0.00019248 |   0.0 |  0.00
Modify  | 0.83181    | 0.83181    | 0.83181    |   0.0 |  0.35
Other   |            | 0.1069     |            |       |  0.05

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

Total # of neighbors = 310540
Ave neighs/atom = 77.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 = 333.191889533359, Press = 2.81530149968305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13815.545     -13815.545     -13986.44      -13986.44       330.60969      330.60969      48204.898      48204.898     -376.16171     -376.16171    
     43000  -13813.3       -13813.3       -13988.708     -13988.708      339.33942      339.33942      48248.687      48248.687     -1727.4149     -1727.4149    
Loop time of 238.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.362 ns/day, 66.324 hours/ns, 4.188 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 237.65     | 237.65     | 237.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16771    | 0.16771    | 0.16771    |   0.0 |  0.07
Output  | 0.0003108  | 0.0003108  | 0.0003108  |   0.0 |  0.00
Modify  | 0.83886    | 0.83886    | 0.83886    |   0.0 |  0.35
Other   |            | 0.1059     |            |       |  0.04

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

Total # of neighbors = 310344
Ave neighs/atom = 77.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.230043698366, Press = 0.922269342205034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13813.3       -13813.3       -13988.708     -13988.708      339.33942      339.33942      48248.687      48248.687     -1727.4149     -1727.4149    
     44000  -13813.324     -13813.324     -13989.556     -13989.556      340.93216      340.93216      48194.855      48194.855     -242.11994     -242.11994    
Loop time of 239.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.361 ns/day, 66.450 hours/ns, 4.180 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 238.12     | 238.12     | 238.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1669     | 0.1669     | 0.1669     |   0.0 |  0.07
Output  | 0.00019231 | 0.00019231 | 0.00019231 |   0.0 |  0.00
Modify  | 0.82947    | 0.82947    | 0.82947    |   0.0 |  0.35
Other   |            | 0.1053     |            |       |  0.04

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

Total # of neighbors = 310270
Ave neighs/atom = 77.5675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
48198.8722937479

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0