# 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 4.079999998211861*${_u_distance}
variable latticeconst_converted equal 4.079999998211861*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.07999999821186
Lattice spacing in x,y,z = 4.08 4.08 4.08
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.8 40.8 40.8)
  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 (40.8 40.8 40.8)
  create_atoms CPU = 0.006 seconds

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_GaoOteroAouadi_2013_AgTaO__MO_112077942578_002
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 67917.3119107017 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_112077942578_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -11227.791     -11227.791     -11400         -11400          333.15         333.15         67917.312      67917.312      2708.289       2708.289     
      1000  -11092.448     -11092.448     -11261.531     -11261.531      327.10175      327.10175      68565.087      68565.087      26.359273      26.359273    
Loop time of 394.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.506 hours/ns, 2.537 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    | 393.27     | 393.27     | 393.27     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1965     | 0.1965     | 0.1965     |   0.0 |  0.05
Output  | 0.00025187 | 0.00025187 | 0.00025187 |   0.0 |  0.00
Modify  | 0.66196    | 0.66196    | 0.66196    |   0.0 |  0.17
Other   |            | 0.09594    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       560000 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -11092.448     -11092.448     -11261.531     -11261.531      327.10175      327.10175      68565.087      68565.087      26.359273      26.359273    
      2000  -11081.04      -11081.04      -11254.938     -11254.938      336.41733      336.41733      68603.865      68603.865     -253.32077     -253.32077    
Loop time of 420.091 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.692 hours/ns, 2.380 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    | 419.11     | 419.11     | 419.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17733    | 0.17733    | 0.17733    |   0.0 |  0.04
Output  | 0.00023688 | 0.00023688 | 0.00023688 |   0.0 |  0.00
Modify  | 0.7084     | 0.7084     | 0.7084     |   0.0 |  0.17
Other   |            | 0.09998    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7084 ave        7084 max        7084 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548852 ave      548852 max      548852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548852
Ave neighs/atom = 137.213
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -11081.04      -11081.04      -11254.938     -11254.938      336.41733      336.41733      68603.865      68603.865     -253.32077     -253.32077    
      3000  -11083.43      -11083.43      -11257.64      -11257.64       337.0204       337.0204       68572.928      68572.928      187.36928      187.36928    
Loop time of 390.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.593 hours/ns, 2.558 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    | 390.03     | 390.03     | 390.03     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16716    | 0.16716    | 0.16716    |   0.0 |  0.04
Output  | 0.00023726 | 0.00023726 | 0.00023726 |   0.0 |  0.00
Modify  | 0.64306    | 0.64306    | 0.64306    |   0.0 |  0.16
Other   |            | 0.09449    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7018 ave        7018 max        7018 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548778 ave      548778 max      548778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548778
Ave neighs/atom = 137.1945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -11083.43      -11083.43      -11257.64      -11257.64       337.0204       337.0204       68572.928      68572.928      187.36928      187.36928    
      4000  -11090.1       -11090.1       -11258.738     -11258.738      326.24256      326.24256      68588.416      68588.416     -410.93494     -410.93494    
Loop time of 391.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.854 hours/ns, 2.552 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    | 390.96     | 390.96     | 390.96     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16879    | 0.16879    | 0.16879    |   0.0 |  0.04
Output  | 0.00028099 | 0.00028099 | 0.00028099 |   0.0 |  0.00
Modify  | 0.64736    | 0.64736    | 0.64736    |   0.0 |  0.17
Other   |            | 0.09494    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7093 ave        7093 max        7093 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548870 ave      548870 max      548870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548870
Ave neighs/atom = 137.2175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -11090.1       -11090.1       -11258.738     -11258.738      326.24256      326.24256      68588.416      68588.416     -410.93494     -410.93494    
      5000  -11084.967     -11084.967     -11258.749     -11258.749      336.19362      336.19362      68536.524      68536.524      504.78354      504.78354    
Loop time of 438.807 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.891 hours/ns, 2.279 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    | 437.76     | 437.76     | 437.76     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18502    | 0.18502    | 0.18502    |   0.0 |  0.04
Output  | 0.00018817 | 0.00018817 | 0.00018817 |   0.0 |  0.00
Modify  | 0.76087    | 0.76087    | 0.76087    |   0.0 |  0.17
Other   |            | 0.1038     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7139 ave        7139 max        7139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548782 ave      548782 max      548782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548782
Ave neighs/atom = 137.1955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928751094575, Press = 20.9421364975382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -11084.967     -11084.967     -11258.749     -11258.749      336.19362      336.19362      68536.524      68536.524      504.78354      504.78354    
      6000  -11086.423     -11086.423     -11258.935     -11258.935      333.73745      333.73745      68566.954      68566.954      176.63417      176.63417    
Loop time of 439.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 122.035 hours/ns, 2.276 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    | 438.25     | 438.25     | 438.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18633    | 0.18633    | 0.18633    |   0.0 |  0.04
Output  | 0.00019262 | 0.00019262 | 0.00019262 |   0.0 |  0.00
Modify  | 0.78828    | 0.78828    | 0.78828    |   0.0 |  0.18
Other   |            | 0.1025     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7142 ave        7142 max        7142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548936 ave      548936 max      548936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548936
Ave neighs/atom = 137.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.756176806745, Press = -4.70079674766496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -11086.423     -11086.423     -11258.935     -11258.935      333.73745      333.73745      68566.954      68566.954      176.63417      176.63417    
      7000  -11085.162     -11085.162     -11259.447     -11259.447      337.16525      337.16525      68571.642      68571.642      58.356039      58.356039    
Loop time of 460.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.938 hours/ns, 2.171 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    | 459.44     | 459.44     | 459.44     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19243    | 0.19243    | 0.19243    |   0.0 |  0.04
Output  | 0.0002387  | 0.0002387  | 0.0002387  |   0.0 |  0.00
Modify  | 0.83722    | 0.83722    | 0.83722    |   0.0 |  0.18
Other   |            | 0.1066     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7154 ave        7154 max        7154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548926 ave      548926 max      548926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548926
Ave neighs/atom = 137.2315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.097115413127, Press = -18.0255008055744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -11085.162     -11085.162     -11259.447     -11259.447      337.16525      337.16525      68571.642      68571.642      58.356039      58.356039    
      8000  -11085.513     -11085.513     -11259.167     -11259.167      335.94491      335.94491      68445.446      68445.446      1873.4927      1873.4927    
Loop time of 423.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.745 hours/ns, 2.359 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    | 422.85     | 422.85     | 422.85     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18111    | 0.18111    | 0.18111    |   0.0 |  0.04
Output  | 0.00024957 | 0.00024957 | 0.00024957 |   0.0 |  0.00
Modify  | 0.75231    | 0.75231    | 0.75231    |   0.0 |  0.18
Other   |            | 0.1001     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7090 ave        7090 max        7090 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548852 ave      548852 max      548852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548852
Ave neighs/atom = 137.213
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.114678454256, Press = 2.1394320494228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -11085.513     -11085.513     -11259.167     -11259.167      335.94491      335.94491      68445.446      68445.446      1873.4927      1873.4927    
      9000  -11084.191     -11084.191     -11257.691     -11257.691      335.64669      335.64669      68624.584      68624.584     -827.10744     -827.10744    
Loop time of 436.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.260 hours/ns, 2.291 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    | 435.47     | 435.47     | 435.47     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18271    | 0.18271    | 0.18271    |   0.0 |  0.04
Output  | 0.00019174 | 0.00019174 | 0.00019174 |   0.0 |  0.00
Modify  | 0.77832    | 0.77832    | 0.77832    |   0.0 |  0.18
Other   |            | 0.1025     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7055 ave        7055 max        7055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       549214 ave      549214 max      549214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549214
Ave neighs/atom = 137.3035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.39886340238, Press = 4.64785148451808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -11084.191     -11084.191     -11257.691     -11257.691      335.64669      335.64669      68624.584      68624.584     -827.10744     -827.10744    
     10000  -11085.083     -11085.083     -11257.928     -11257.928      334.37963      334.37963      68563.318      68563.318      82.575464      82.575464    
Loop time of 411.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.268 hours/ns, 2.431 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    | 410.37     | 410.37     | 410.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17498    | 0.17498    | 0.17498    |   0.0 |  0.04
Output  | 0.00019265 | 0.00019265 | 0.00019265 |   0.0 |  0.00
Modify  | 0.71911    | 0.71911    | 0.71911    |   0.0 |  0.17
Other   |            | 0.09798    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7028 ave        7028 max        7028 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548732 ave      548732 max      548732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548732
Ave neighs/atom = 137.183
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.428991383655, Press = -1.89248492209257
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -11085.083     -11085.083     -11257.928     -11257.928      334.37963      334.37963      68563.318      68563.318      82.575464      82.575464    
     11000  -11086.902     -11086.902     -11256.772     -11256.772      328.62505      328.62505      68624.388      68624.388     -1038.7382     -1038.7382    
Loop time of 408.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.415 hours/ns, 2.449 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    | 407.31     | 407.31     | 407.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17823    | 0.17823    | 0.17823    |   0.0 |  0.04
Output  | 0.00019619 | 0.00019619 | 0.00019619 |   0.0 |  0.00
Modify  | 0.70708    | 0.70708    | 0.70708    |   0.0 |  0.17
Other   |            | 0.09718    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7159 ave        7159 max        7159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548952 ave      548952 max      548952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548952
Ave neighs/atom = 137.238
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.520862891559, Press = -2.4633588456318
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -11086.902     -11086.902     -11256.772     -11256.772      328.62505      328.62505      68624.388      68624.388     -1038.7382     -1038.7382    
     12000  -11088.53      -11088.53      -11259.334     -11259.334      330.43049      330.43049      68530.876      68530.876      364.35528      364.35528    
Loop time of 419.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.638 hours/ns, 2.382 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    | 418.87     | 418.87     | 418.87     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18294    | 0.18294    | 0.18294    |   0.0 |  0.04
Output  | 0.0002631  | 0.0002631  | 0.0002631  |   0.0 |  0.00
Modify  | 0.74351    | 0.74351    | 0.74351    |   0.0 |  0.18
Other   |            | 0.09979    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7177 ave        7177 max        7177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548794 ave      548794 max      548794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548794
Ave neighs/atom = 137.1985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.355147014895, Press = -4.46654611981652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -11088.53      -11088.53      -11259.334     -11259.334      330.43049      330.43049      68530.876      68530.876      364.35528      364.35528    
     13000  -11086.807     -11086.807     -11256.827     -11256.827      328.91611      328.91611      68542.809      68542.809      297.82285      297.82285    
Loop time of 436.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.388 hours/ns, 2.288 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    | 435.93     | 435.93     | 435.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18495    | 0.18495    | 0.18495    |   0.0 |  0.04
Output  | 0.00019133 | 0.00019133 | 0.00019133 |   0.0 |  0.00
Modify  | 0.77449    | 0.77449    | 0.77449    |   0.0 |  0.18
Other   |            | 0.1021     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7171 ave        7171 max        7171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548948 ave      548948 max      548948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548948
Ave neighs/atom = 137.237
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.556473656983, Press = -0.515754529597757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -11086.807     -11086.807     -11256.827     -11256.827      328.91611      328.91611      68542.809      68542.809      297.82285      297.82285    
     14000  -11081.694     -11081.694     -11256.775     -11256.775      338.70667      338.70667      68568.514      68568.514      102.76465      102.76465    
Loop time of 442.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.917 hours/ns, 2.260 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    | 441.42     | 441.42     | 441.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18841    | 0.18841    | 0.18841    |   0.0 |  0.04
Output  | 0.00019189 | 0.00019189 | 0.00019189 |   0.0 |  0.00
Modify  | 0.789      | 0.789      | 0.789      |   0.0 |  0.18
Other   |            | 0.103      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7143 ave        7143 max        7143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548968 ave      548968 max      548968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548968
Ave neighs/atom = 137.242
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.619736405068, Press = -0.296645285287261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -11081.694     -11081.694     -11256.775     -11256.775      338.70667      338.70667      68568.514      68568.514      102.76465      102.76465    
     15000  -11082.94      -11082.94      -11256.679     -11256.679      336.10851      336.10851      68602.38       68602.38      -391.60265     -391.60265    
Loop time of 395.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.819 hours/ns, 2.529 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    | 394.4      | 394.4      | 394.4      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17238    | 0.17238    | 0.17238    |   0.0 |  0.04
Output  | 0.00019451 | 0.00019451 | 0.00019451 |   0.0 |  0.00
Modify  | 0.68291    | 0.68291    | 0.68291    |   0.0 |  0.17
Other   |            | 0.09346    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7074 ave        7074 max        7074 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548966 ave      548966 max      548966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548966
Ave neighs/atom = 137.2415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.58317476637, Press = 3.70623969218775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -11082.94      -11082.94      -11256.679     -11256.679      336.10851      336.10851      68602.38       68602.38      -391.60265     -391.60265    
     16000  -11086.326     -11086.326     -11255.054     -11255.054      326.416        326.416        68669.256      68669.256     -1354.1104     -1354.1104    
Loop time of 391.237 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.677 hours/ns, 2.556 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    | 390.3      | 390.3      | 390.3      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16939    | 0.16939    | 0.16939    |   0.0 |  0.04
Output  | 0.00019249 | 0.00019249 | 0.00019249 |   0.0 |  0.00
Modify  | 0.67208    | 0.67208    | 0.67208    |   0.0 |  0.17
Other   |            | 0.09279    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7015 ave        7015 max        7015 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548842 ave      548842 max      548842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548842
Ave neighs/atom = 137.2105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.429845268269, Press = -2.3903943939701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -11086.326     -11086.326     -11255.054     -11255.054      326.416        326.416        68669.256      68669.256     -1354.1104     -1354.1104    
     17000  -11089.702     -11089.702     -11259.333     -11259.333      328.16346      328.16346      68508.437      68508.437      895.08906      895.08906    
Loop time of 392.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.965 hours/ns, 2.549 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    | 391.34     | 391.34     | 391.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17061    | 0.17061    | 0.17061    |   0.0 |  0.04
Output  | 0.00022827 | 0.00022827 | 0.00022827 |   0.0 |  0.00
Modify  | 0.6728     | 0.6728     | 0.6728     |   0.0 |  0.17
Other   |            | 0.09244    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7061 ave        7061 max        7061 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548624 ave      548624 max      548624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548624
Ave neighs/atom = 137.156
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.282263607308, Press = -1.85660030965181
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -11089.702     -11089.702     -11259.333     -11259.333      328.16346      328.16346      68508.437      68508.437      895.08906      895.08906    
     18000  -11088.036     -11088.036     -11260.136     -11260.136      332.93916      332.93916      68598.085      68598.085     -461.96318     -461.96318    
Loop time of 437.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.659 hours/ns, 2.283 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    | 436.9      | 436.9      | 436.9      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18749    | 0.18749    | 0.18749    |   0.0 |  0.04
Output  | 0.00019211 | 0.00019211 | 0.00019211 |   0.0 |  0.00
Modify  | 0.78153    | 0.78153    | 0.78153    |   0.0 |  0.18
Other   |            | 0.1027     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7207 ave        7207 max        7207 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       549186 ave      549186 max      549186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549186
Ave neighs/atom = 137.2965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.359478662344, Press = 0.883301713310229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -11088.036     -11088.036     -11260.136     -11260.136      332.93916      332.93916      68598.085      68598.085     -461.96318     -461.96318    
     19000  -11082.591     -11082.591     -11257.248     -11257.248      337.88546      337.88546      68538.962      68538.962      310.95854      310.95854    
Loop time of 412.85 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.681 hours/ns, 2.422 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    | 411.85     | 411.85     | 411.85     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17855    | 0.17855    | 0.17855    |   0.0 |  0.04
Output  | 0.00019371 | 0.00019371 | 0.00019371 |   0.0 |  0.00
Modify  | 0.72719    | 0.72719    | 0.72719    |   0.0 |  0.18
Other   |            | 0.09846    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7141 ave        7141 max        7141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548734 ave      548734 max      548734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548734
Ave neighs/atom = 137.1835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.422260790442, Press = -0.223124576521123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -11082.591     -11082.591     -11257.248     -11257.248      337.88546      337.88546      68538.962      68538.962      310.95854      310.95854    
     20000  -11081.822     -11081.822     -11257.718     -11257.718      340.28198      340.28198      68606.578      68606.578     -501.46562     -501.46562    
Loop time of 455.861 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.628 hours/ns, 2.194 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    | 454.74     | 454.74     | 454.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19314    | 0.19314    | 0.19314    |   0.0 |  0.04
Output  | 0.00019456 | 0.00019456 | 0.00019456 |   0.0 |  0.00
Modify  | 0.82469    | 0.82469    | 0.82469    |   0.0 |  0.18
Other   |            | 0.1059     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7222 ave        7222 max        7222 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548928 ave      548928 max      548928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548928
Ave neighs/atom = 137.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.433698245577, Press = 1.04167355552885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -11081.822     -11081.822     -11257.718     -11257.718      340.28198      340.28198      68606.578      68606.578     -501.46562     -501.46562    
     21000  -11086.139     -11086.139     -11256.926     -11256.926      330.39846      330.39846      68666.447      68666.447     -1387.7925     -1387.7925    
Loop time of 418.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.182 hours/ns, 2.391 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    | 417.24     | 417.24     | 417.24     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18341    | 0.18341    | 0.18341    |   0.0 |  0.04
Output  | 0.00019384 | 0.00019384 | 0.00019384 |   0.0 |  0.00
Modify  | 0.73518    | 0.73518    | 0.73518    |   0.0 |  0.18
Other   |            | 0.1006     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7197 ave        7197 max        7197 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548720 ave      548720 max      548720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548720
Ave neighs/atom = 137.18
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.464001788235, Press = -0.132958876607197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -11086.139     -11086.139     -11256.926     -11256.926      330.39846      330.39846      68666.447      68666.447     -1387.7925     -1387.7925    
     22000  -11087.535     -11087.535     -11258.474     -11258.474      330.692        330.692        68524.563      68524.563      487.29742      487.29742    
Loop time of 390.037 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.344 hours/ns, 2.564 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    | 389.1      | 389.1      | 389.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16739    | 0.16739    | 0.16739    |   0.0 |  0.04
Output  | 0.00019359 | 0.00019359 | 0.00019359 |   0.0 |  0.00
Modify  | 0.67068    | 0.67068    | 0.67068    |   0.0 |  0.17
Other   |            | 0.09491    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7004 ave        7004 max        7004 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548564 ave      548564 max      548564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548564
Ave neighs/atom = 137.141
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.527102700342, Press = -4.2002122888975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -11087.535     -11087.535     -11258.474     -11258.474      330.692        330.692        68524.563      68524.563      487.29742      487.29742    
     23000  -11089.355     -11089.355     -11260.344     -11260.344      330.79085      330.79085      68497.025      68497.025      879.30917      879.30917    
Loop time of 418.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.356 hours/ns, 2.387 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    | 417.87     | 417.87     | 417.87     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17924    | 0.17924    | 0.17924    |   0.0 |  0.04
Output  | 0.00019256 | 0.00019256 | 0.00019256 |   0.0 |  0.00
Modify  | 0.73463    | 0.73463    | 0.73463    |   0.0 |  0.18
Other   |            | 0.09994    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7123 ave        7123 max        7123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548998 ave      548998 max      548998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548998
Ave neighs/atom = 137.2495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.597258645105, Press = 0.0976460340141209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -11089.355     -11089.355     -11260.344     -11260.344      330.79085      330.79085      68497.025      68497.025      879.30917      879.30917    
     24000  -11086.044     -11086.044     -11259.171     -11259.171      334.92644      334.92644      68584.731      68584.731     -213.43703     -213.43703    
Loop time of 457.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.010 hours/ns, 2.187 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    | 456.12     | 456.12     | 456.12     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18953    | 0.18953    | 0.18953    |   0.0 |  0.04
Output  | 0.00023877 | 0.00023877 | 0.00023877 |   0.0 |  0.00
Modify  | 0.81978    | 0.81978    | 0.81978    |   0.0 |  0.18
Other   |            | 0.1061     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7113 ave        7113 max        7113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       549142 ave      549142 max      549142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549142
Ave neighs/atom = 137.2855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.526410938102, Press = 1.38998761512311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -11086.044     -11086.044     -11259.171     -11259.171      334.92644      334.92644      68584.731      68584.731     -213.43703     -213.43703    
     25000  -11081.651     -11081.651     -11256.202     -11256.202      337.68154      337.68154      68655.139      68655.139     -1342.7025     -1342.7025    
Loop time of 418.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.153 hours/ns, 2.391 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    | 417.14     | 417.14     | 417.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17905    | 0.17905    | 0.17905    |   0.0 |  0.04
Output  | 0.0001907  | 0.0001907  | 0.0001907  |   0.0 |  0.00
Modify  | 0.73339    | 0.73339    | 0.73339    |   0.0 |  0.18
Other   |            | 0.09871    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7160 ave        7160 max        7160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548872 ave      548872 max      548872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548872
Ave neighs/atom = 137.218
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.538779372365, Press = -0.166921576678122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -11081.651     -11081.651     -11256.202     -11256.202      337.68154      337.68154      68655.139      68655.139     -1342.7025     -1342.7025    
     26000  -11083.325     -11083.325     -11257.416     -11257.416      336.79194      336.79194      68558.221      68558.221      263.99786      263.99786    
Loop time of 390.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.535 hours/ns, 2.559 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    | 389.79     | 389.79     | 389.79     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1709     | 0.1709     | 0.1709     |   0.0 |  0.04
Output  | 0.00019335 | 0.00019335 | 0.00019335 |   0.0 |  0.00
Modify  | 0.66708    | 0.66708    | 0.66708    |   0.0 |  0.17
Other   |            | 0.09313    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7149 ave        7149 max        7149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548686 ave      548686 max      548686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548686
Ave neighs/atom = 137.1715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.58535874192, Press = -0.366887624535335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -11083.325     -11083.325     -11257.416     -11257.416      336.79194      336.79194      68558.221      68558.221      263.99786      263.99786    
     27000  -11090.21      -11090.21      -11261.882     -11261.882      332.11216      332.11216      68576.676      68576.676     -236.99119     -236.99119    
Loop time of 390.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.357 hours/ns, 2.564 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    | 389.15     | 389.15     | 389.15     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1704     | 0.1704     | 0.1704     |   0.0 |  0.04
Output  | 0.000194   | 0.000194   | 0.000194   |   0.0 |  0.00
Modify  | 0.66647    | 0.66647    | 0.66647    |   0.0 |  0.17
Other   |            | 0.0932     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7182 ave        7182 max        7182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       549000 ave      549000 max      549000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549000
Ave neighs/atom = 137.25
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.531280136582, Press = 0.65897651127877
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -11090.21      -11090.21      -11261.882     -11261.882      332.11216      332.11216      68576.676      68576.676     -236.99119     -236.99119    
     28000  -11083.473     -11083.473     -11257.267     -11257.267      336.21504      336.21504      68611.067      68611.067     -594.52091     -594.52091    
Loop time of 391.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.628 hours/ns, 2.557 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    | 390.13     | 390.13     | 390.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1698     | 0.1698     | 0.1698     |   0.0 |  0.04
Output  | 0.00019406 | 0.00019406 | 0.00019406 |   0.0 |  0.00
Modify  | 0.66819    | 0.66819    | 0.66819    |   0.0 |  0.17
Other   |            | 0.09341    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7084 ave        7084 max        7084 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548908 ave      548908 max      548908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548908
Ave neighs/atom = 137.227
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.590693219091, Press = -0.70922232253193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -11083.473     -11083.473     -11257.267     -11257.267      336.21504      336.21504      68611.067      68611.067     -594.52091     -594.52091    
     29000  -11084.592     -11084.592     -11256.521     -11256.521      332.6079       332.6079       68564.41       68564.41       100.95478      100.95478    
Loop time of 409.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.879 hours/ns, 2.439 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    | 408.98     | 408.98     | 408.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17454    | 0.17454    | 0.17454    |   0.0 |  0.04
Output  | 0.00019374 | 0.00019374 | 0.00019374 |   0.0 |  0.00
Modify  | 0.71275    | 0.71275    | 0.71275    |   0.0 |  0.17
Other   |            | 0.09693    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6940 ave        6940 max        6940 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548798 ave      548798 max      548798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548798
Ave neighs/atom = 137.1995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.54286634883, Press = -0.0825438306747018
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -11084.592     -11084.592     -11256.521     -11256.521      332.6079       332.6079       68564.41       68564.41       100.95478      100.95478    
     30000  -11086.153     -11086.153     -11255.621     -11255.621      327.84633      327.84633      68589.268      68589.268     -350.87507     -350.87507    
Loop time of 428.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.890 hours/ns, 2.336 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    | 426.97     | 426.97     | 426.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18291    | 0.18291    | 0.18291    |   0.0 |  0.04
Output  | 0.00023175 | 0.00023175 | 0.00023175 |   0.0 |  0.00
Modify  | 0.75351    | 0.75351    | 0.75351    |   0.0 |  0.18
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7057 ave        7057 max        7057 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548816 ave      548816 max      548816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548816
Ave neighs/atom = 137.204
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.620537293407, Press = -1.19671522233178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -11086.153     -11086.153     -11255.621     -11255.621      327.84633      327.84633      68589.268      68589.268     -350.87507     -350.87507    
     31000  -11082.922     -11082.922     -11255.676     -11255.676      334.20362      334.20362      68472.515      68472.515      1352.6704      1352.6704    
Loop time of 455.663 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.573 hours/ns, 2.195 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    | 454.54     | 454.54     | 454.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1919     | 0.1919     | 0.1919     |   0.0 |  0.04
Output  | 0.00024532 | 0.00024532 | 0.00024532 |   0.0 |  0.00
Modify  | 0.82848    | 0.82848    | 0.82848    |   0.0 |  0.18
Other   |            | 0.1056     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7078 ave        7078 max        7078 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548776 ave      548776 max      548776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548776
Ave neighs/atom = 137.194
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.658280018962, Press = -0.516361487463561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -11082.922     -11082.922     -11255.676     -11255.676      334.20362      334.20362      68472.515      68472.515      1352.6704      1352.6704    
     32000  -11082.214     -11082.214     -11257.562     -11257.562      339.2213       339.2213       68571.812      68571.812      96.903408      96.903408    
Loop time of 434.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.668 hours/ns, 2.302 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    | 433.34     | 433.34     | 433.34     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18707    | 0.18707    | 0.18707    |   0.0 |  0.04
Output  | 0.00019519 | 0.00019519 | 0.00019519 |   0.0 |  0.00
Modify  | 0.77665    | 0.77665    | 0.77665    |   0.0 |  0.18
Other   |            | 0.1028     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7212 ave        7212 max        7212 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       549066 ave      549066 max      549066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549066
Ave neighs/atom = 137.2665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.63600923464, Press = 1.7854314092056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -11082.214     -11082.214     -11257.562     -11257.562      339.2213       339.2213       68571.812      68571.812      96.903408      96.903408    
     33000  -11088.108     -11088.108     -11261.159     -11261.159      334.77802      334.77802      68632.071      68632.071     -994.22543     -994.22543    
Loop time of 449.543 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.873 hours/ns, 2.224 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    | 448.44     | 448.44     | 448.44     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19258    | 0.19258    | 0.19258    |   0.0 |  0.04
Output  | 0.00019236 | 0.00019236 | 0.00019236 |   0.0 |  0.00
Modify  | 0.80408    | 0.80408    | 0.80408    |   0.0 |  0.18
Other   |            | 0.1043     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7180 ave        7180 max        7180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548954 ave      548954 max      548954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548954
Ave neighs/atom = 137.2385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.594787797494, Press = -0.224842808528148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -11088.108     -11088.108     -11261.159     -11261.159      334.77802      334.77802      68632.071      68632.071     -994.22543     -994.22543    
     34000  -11090.675     -11090.675     -11262.327     -11262.327      332.07231      332.07231      68512.799      68512.799      837.44875      837.44875    
Loop time of 440.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.393 hours/ns, 2.270 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    | 439.54     | 439.54     | 439.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18868    | 0.18868    | 0.18868    |   0.0 |  0.04
Output  | 0.0001921  | 0.0001921  | 0.0001921  |   0.0 |  0.00
Modify  | 0.78194    | 0.78194    | 0.78194    |   0.0 |  0.18
Other   |            | 0.1023     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7114 ave        7114 max        7114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548620 ave      548620 max      548620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548620
Ave neighs/atom = 137.155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.551733848117, Press = 0.0312166567511734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -11090.675     -11090.675     -11262.327     -11262.327      332.07231      332.07231      68512.799      68512.799      837.44875      837.44875    
     35000  -11084.432     -11084.432     -11255.964     -11255.964      331.8398       331.8398       68589.101      68589.101     -350.4334      -350.4334     
Loop time of 448.321 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.534 hours/ns, 2.231 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    | 447.23     | 447.23     | 447.23     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18881    | 0.18881    | 0.18881    |   0.0 |  0.04
Output  | 0.00018972 | 0.00018972 | 0.00018972 |   0.0 |  0.00
Modify  | 0.79539    | 0.79539    | 0.79539    |   0.0 |  0.18
Other   |            | 0.1046     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7209 ave        7209 max        7209 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548904 ave      548904 max      548904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548904
Ave neighs/atom = 137.226
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475356440359, Press = 0.381987404599477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -11084.432     -11084.432     -11255.964     -11255.964      331.8398       331.8398       68589.101      68589.101     -350.4334      -350.4334     
     36000  -11088.212     -11088.212     -11259.551     -11259.551      331.46801      331.46801      68607.286      68607.286     -480.9955      -480.9955     
Loop time of 391.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.627 hours/ns, 2.557 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    | 390.12     | 390.12     | 390.12     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1702     | 0.1702     | 0.1702     |   0.0 |  0.04
Output  | 0.00019251 | 0.00019251 | 0.00019251 |   0.0 |  0.00
Modify  | 0.67245    | 0.67245    | 0.67245    |   0.0 |  0.17
Other   |            | 0.09527    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7082 ave        7082 max        7082 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548964 ave      548964 max      548964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548964
Ave neighs/atom = 137.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.44377162262, Press = 0.152352856865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -11088.212     -11088.212     -11259.551     -11259.551      331.46801      331.46801      68607.286      68607.286     -480.9955      -480.9955     
     37000  -11088.11      -11088.11      -11260.626     -11260.626      333.74475      333.74475      68609.47       68609.47      -752.81659     -752.81659    
Loop time of 390.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.564 hours/ns, 2.559 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    | 389.89     | 389.89     | 389.89     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16946    | 0.16946    | 0.16946    |   0.0 |  0.04
Output  | 0.00019265 | 0.00019265 | 0.00019265 |   0.0 |  0.00
Modify  | 0.67359    | 0.67359    | 0.67359    |   0.0 |  0.17
Other   |            | 0.09529    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7069 ave        7069 max        7069 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548872 ave      548872 max      548872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548872
Ave neighs/atom = 137.218
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.398497259678, Press = -1.05934157709231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -11088.11      -11088.11      -11260.626     -11260.626      333.74475      333.74475      68609.47       68609.47      -752.81659     -752.81659    
     38000  -11084.516     -11084.516     -11259.156     -11259.156      337.85341      337.85341      68504.264      68504.264      910.86078      910.86078    
Loop time of 390.667 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.519 hours/ns, 2.560 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    | 389.73     | 389.73     | 389.73     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17167    | 0.17167    | 0.17167    |   0.0 |  0.04
Output  | 0.00054933 | 0.00054933 | 0.00054933 |   0.0 |  0.00
Modify  | 0.67301    | 0.67301    | 0.67301    |   0.0 |  0.17
Other   |            | 0.09574    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           7164 ave        7164 max        7164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       548810 ave      548810 max      548810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0