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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8493.9169     -8493.9169     -8579.9999     -8579.9999      333.15         333.15         23173.502      23173.502      3967.7587      3967.7587    
      1000  -8401.5983     -8401.5983     -8486.6994     -8486.6994      329.34999      329.34999      23431.854      23431.854     -1248.5416     -1248.5416    
Loop time of 19.0975 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.524 ns/day, 5.305 hours/ns, 52.363 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 19.016     | 19.016     | 19.016     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.08
Output  | 0.00012552 | 0.00012552 | 0.00012552 |   0.0 |  0.00
Modify  | 0.060233   | 0.060233   | 0.060233   |   0.0 |  0.32
Other   |            | 0.005582   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 4.024 ns/day, 5.964 hours/ns, 46.578 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.389     | 21.389     | 21.389     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.07
Output  | 6.4802e-05 | 6.4802e-05 | 6.4802e-05 |   0.0 |  0.00
Modify  | 0.059822   | 0.059822   | 0.059822   |   0.0 |  0.28
Other   |            | 0.005458   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128260 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 3.995 ns/day, 6.008 hours/ns, 46.238 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.547     | 21.547     | 21.547     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015047   | 0.015047   | 0.015047   |   0.0 |  0.07
Output  | 5.1767e-05 | 5.1767e-05 | 5.1767e-05 |   0.0 |  0.00
Modify  | 0.05967    | 0.05967    | 0.05967    |   0.0 |  0.28
Other   |            | 0.00545    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128328 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 3.978 ns/day, 6.033 hours/ns, 46.040 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.64      | 21.64      | 21.64      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015014   | 0.015014   | 0.015014   |   0.0 |  0.07
Output  | 5.346e-05  | 5.346e-05  | 5.346e-05  |   0.0 |  0.00
Modify  | 0.059643   | 0.059643   | 0.059643   |   0.0 |  0.27
Other   |            | 0.005456   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128316 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 3.972 ns/day, 6.042 hours/ns, 45.976 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.67      | 21.67      | 21.67      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.07
Output  | 3.8131e-05 | 3.8131e-05 | 3.8131e-05 |   0.0 |  0.00
Modify  | 0.059984   | 0.059984   | 0.059984   |   0.0 |  0.28
Other   |            | 0.005454   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128330 ave      128330 max      128330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128330
Ave neighs/atom = 64.165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.749681283259, Press = -69.6823065932624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8404.1112     -8404.1112     -8488.3684     -8488.3684      326.08388      326.08388      23419.948      23419.948     -592.36947     -592.36947    
      6000  -8401.7327     -8401.7327     -8488.7597     -8488.7597      336.80356      336.80356      23403.761      23403.761      649.24678      649.24678    
Loop time of 21.7495 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.973 ns/day, 6.042 hours/ns, 45.978 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.667     | 21.667     | 21.667     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.07
Output  | 3.9505e-05 | 3.9505e-05 | 3.9505e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.29
Other   |            | 0.005494   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128316 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128316
Ave neighs/atom = 64.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.744667408965, Press = 38.9833529747219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8401.7327     -8401.7327     -8488.7597     -8488.7597      336.80356      336.80356      23403.761      23403.761      649.24678      649.24678    
      7000  -8403.8093     -8403.8093     -8489.7771     -8489.7771      332.7042       332.7042       23381.766      23381.766      2087.3685      2087.3685    
Loop time of 21.7276 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.035 hours/ns, 46.024 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.645     | 21.645     | 21.645     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015065   | 0.015065   | 0.015065   |   0.0 |  0.07
Output  | 2.9686e-05 | 2.9686e-05 | 2.9686e-05 |   0.0 |  0.00
Modify  | 0.061953   | 0.061953   | 0.061953   |   0.0 |  0.29
Other   |            | 0.005472   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128296 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.55761554873, Press = -31.6376864706675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8403.8093     -8403.8093     -8489.7771     -8489.7771      332.7042       332.7042       23381.766      23381.766      2087.3685      2087.3685    
      8000  -8400.4579     -8400.4579     -8486.5413     -8486.5413      333.15155      333.15155      23451.035      23451.035     -2349.7464     -2349.7464    
Loop time of 21.7569 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.971 ns/day, 6.044 hours/ns, 45.962 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.674     | 21.674     | 21.674     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015092   | 0.015092   | 0.015092   |   0.0 |  0.07
Output  | 4.3392e-05 | 4.3392e-05 | 4.3392e-05 |   0.0 |  0.00
Modify  | 0.061978   | 0.061978   | 0.061978   |   0.0 |  0.28
Other   |            | 0.005481   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128266 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.145145966721, Press = -14.8729314814737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8400.4579     -8400.4579     -8486.5413     -8486.5413      333.15155      333.15155      23451.035      23451.035     -2349.7464     -2349.7464    
      9000  -8405.068      -8405.068      -8487.1312     -8487.1312      317.59324      317.59324      23412.455      23412.455      144.88037      144.88037    
Loop time of 21.8082 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.962 ns/day, 6.058 hours/ns, 45.854 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.726     | 21.726     | 21.726     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.07
Output  | 2.9125e-05 | 2.9125e-05 | 2.9125e-05 |   0.0 |  0.00
Modify  | 0.061993   | 0.061993   | 0.061993   |   0.0 |  0.28
Other   |            | 0.005494   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128290 ave      128290 max      128290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128290
Ave neighs/atom = 64.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.813301915024, Press = 14.8872884823045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8405.068      -8405.068      -8487.1312     -8487.1312      317.59324      317.59324      23412.455      23412.455      144.88037      144.88037    
     10000  -8400.2217     -8400.2217     -8490.853      -8490.853       350.75252      350.75252      23380.696      23380.696      2249.5232      2249.5232    
Loop time of 21.7587 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.971 ns/day, 6.044 hours/ns, 45.959 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.676     | 21.676     | 21.676     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.07
Output  | 3.9544e-05 | 3.9544e-05 | 3.9544e-05 |   0.0 |  0.00
Modify  | 0.061923   | 0.061923   | 0.061923   |   0.0 |  0.28
Other   |            | 0.005515   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128306 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.557666260924, Press = -1.46977953190997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8400.2217     -8400.2217     -8490.853      -8490.853       350.75252      350.75252      23380.696      23380.696      2249.5232      2249.5232    
     11000  -8403.6178     -8403.6178     -8487.6553     -8487.6553      325.23387      325.23387      23428.26       23428.26      -922.51957     -922.51957    
Loop time of 21.716 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.979 ns/day, 6.032 hours/ns, 46.049 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.634     | 21.634     | 21.634     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.07
Output  | 2.9625e-05 | 2.9625e-05 | 2.9625e-05 |   0.0 |  0.00
Modify  | 0.061983   | 0.061983   | 0.061983   |   0.0 |  0.29
Other   |            | 0.005455   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128308 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.030945443622, Press = -11.1345948868201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8403.6178     -8403.6178     -8487.6553     -8487.6553      325.23387      325.23387      23428.26       23428.26      -922.51957     -922.51957    
     12000  -8400.8855     -8400.8855     -8487.9424     -8487.9424      336.91926      336.91926      23427.395      23427.395     -806.40014     -806.40014    
Loop time of 21.7046 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.981 ns/day, 6.029 hours/ns, 46.073 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.622     | 21.622     | 21.622     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014913   | 0.014913   | 0.014913   |   0.0 |  0.07
Output  | 3.5326e-05 | 3.5326e-05 | 3.5326e-05 |   0.0 |  0.00
Modify  | 0.061952   | 0.061952   | 0.061952   |   0.0 |  0.29
Other   |            | 0.005457   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128328 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.078631390375, Press = 11.5594188437747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8400.8855     -8400.8855     -8487.9424     -8487.9424      336.91926      336.91926      23427.395      23427.395     -806.40014     -806.40014    
     13000  -8405.8083     -8405.8083     -8490.2241     -8490.2241      326.69782      326.69782      23353.03       23353.03       4016.3981      4016.3981    
Loop time of 21.6823 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.023 hours/ns, 46.121 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.6       | 21.6       | 21.6       |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.07
Output  | 2.8945e-05 | 2.8945e-05 | 2.8945e-05 |   0.0 |  0.00
Modify  | 0.061867   | 0.061867   | 0.061867   |   0.0 |  0.29
Other   |            | 0.005463   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128290 ave      128290 max      128290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128290
Ave neighs/atom = 64.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033565513587, Press = -1.10016784780339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8405.8083     -8405.8083     -8490.2241     -8490.2241      326.69782      326.69782      23353.03       23353.03       4016.3981      4016.3981    
     14000  -8397.4131     -8397.4131     -8487.737      -8487.737       349.56287      349.56287      23453.312      23453.312     -2437.0562     -2437.0562    
Loop time of 21.6444 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.992 ns/day, 6.012 hours/ns, 46.201 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.562     | 21.562     | 21.562     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.07
Output  | 5.3902e-05 | 5.3902e-05 | 5.3902e-05 |   0.0 |  0.00
Modify  | 0.061842   | 0.061842   | 0.061842   |   0.0 |  0.29
Other   |            | 0.00546    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128306 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.187020238743, Press = -4.75568973279847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8397.4131     -8397.4131     -8487.737      -8487.737       349.56287      349.56287      23453.312      23453.312     -2437.0562     -2437.0562    
     15000  -8403.855      -8403.855      -8490.8628     -8490.8628      336.72921      336.72921      23408.583      23408.583      114.4501       114.4501     
Loop time of 21.6814 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.023 hours/ns, 46.122 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.599     | 21.599     | 21.599     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.07
Output  | 3.9594e-05 | 3.9594e-05 | 3.9594e-05 |   0.0 |  0.00
Modify  | 0.061824   | 0.061824   | 0.061824   |   0.0 |  0.29
Other   |            | 0.005466   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128248 ave      128248 max      128248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128248
Ave neighs/atom = 64.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.338824196224, Press = 4.58730352991986
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8403.855      -8403.855      -8490.8628     -8490.8628      336.72921      336.72921      23408.583      23408.583      114.4501       114.4501     
     16000  -8404.406      -8404.406      -8489.2417     -8489.2417      328.32279      328.32279      23405.285      23405.285      466.22102      466.22102    
Loop time of 21.7616 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.970 ns/day, 6.045 hours/ns, 45.953 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.679     | 21.679     | 21.679     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.07
Output  | 2.8704e-05 | 2.8704e-05 | 2.8704e-05 |   0.0 |  0.00
Modify  | 0.061879   | 0.061879   | 0.061879   |   0.0 |  0.28
Other   |            | 0.005461   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128284 ave      128284 max      128284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128284
Ave neighs/atom = 64.142
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.32853967123, Press = -1.92819195147865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8404.406      -8404.406      -8489.2417     -8489.2417      328.32279      328.32279      23405.285      23405.285      466.22102      466.22102    
     17000  -8404.8537     -8404.8537     -8490.2671     -8490.2671      330.55878      330.55878      23422.629      23422.629     -958.86405     -958.86405    
Loop time of 21.8219 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.959 ns/day, 6.062 hours/ns, 45.826 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.74      | 21.74      | 21.74      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.07
Output  | 2.8423e-05 | 2.8423e-05 | 2.8423e-05 |   0.0 |  0.00
Modify  | 0.061873   | 0.061873   | 0.061873   |   0.0 |  0.28
Other   |            | 0.005457   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128288 ave      128288 max      128288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128288
Ave neighs/atom = 64.144
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.026998223794, Press = -1.55285144720789
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8404.8537     -8404.8537     -8490.2671     -8490.2671      330.55878      330.55878      23422.629      23422.629     -958.86405     -958.86405    
     18000  -8402.4195     -8402.4195     -8487.9468     -8487.9468      330.99941      330.99941      23434.745      23434.745     -1365.7215     -1365.7215    
Loop time of 21.8072 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.962 ns/day, 6.058 hours/ns, 45.856 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.725     | 21.725     | 21.725     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014932   | 0.014932   | 0.014932   |   0.0 |  0.07
Output  | 3.9594e-05 | 3.9594e-05 | 3.9594e-05 |   0.0 |  0.00
Modify  | 0.061882   | 0.061882   | 0.061882   |   0.0 |  0.28
Other   |            | 0.005487   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128258 ave      128258 max      128258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128258
Ave neighs/atom = 64.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.983302370212, Press = 0.601780853924278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8402.4195     -8402.4195     -8487.9468     -8487.9468      330.99941      330.99941      23434.745      23434.745     -1365.7215     -1365.7215    
     19000  -8405.4703     -8405.4703     -8492.1551     -8492.1551      335.479        335.479        23393.951      23393.951      896.67568      896.67568    
Loop time of 21.6671 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.988 ns/day, 6.019 hours/ns, 46.153 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.585     | 21.585     | 21.585     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014973   | 0.014973   | 0.014973   |   0.0 |  0.07
Output  | 2.9596e-05 | 2.9596e-05 | 2.9596e-05 |   0.0 |  0.00
Modify  | 0.061883   | 0.061883   | 0.061883   |   0.0 |  0.29
Other   |            | 0.00548    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128260 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.877357049957, Press = 2.59933496148578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8405.4703     -8405.4703     -8492.1551     -8492.1551      335.479        335.479        23393.951      23393.951      896.67568      896.67568    
     20000  -8401.5794     -8401.5794     -8487.2137     -8487.2137      331.4136       331.4136       23402.602      23402.602      1027.9206      1027.9206    
Loop time of 21.7284 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.036 hours/ns, 46.023 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.646     | 21.646     | 21.646     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.07
Output  | 2.8493e-05 | 2.8493e-05 | 2.8493e-05 |   0.0 |  0.00
Modify  | 0.061905   | 0.061905   | 0.061905   |   0.0 |  0.28
Other   |            | 0.005459   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128264 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.751139753097, Press = -2.36679538084577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8401.5794     -8401.5794     -8487.2137     -8487.2137      331.4136       331.4136       23402.602      23402.602      1027.9206      1027.9206    
     21000  -8407.4189     -8407.4189     -8490.0732     -8490.0732      319.88043      319.88043      23445.061      23445.061     -2604.0565     -2604.0565    
Loop time of 21.767 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.969 ns/day, 6.046 hours/ns, 45.941 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.685     | 21.685     | 21.685     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.07
Output  | 3.9965e-05 | 3.9965e-05 | 3.9965e-05 |   0.0 |  0.00
Modify  | 0.061924   | 0.061924   | 0.061924   |   0.0 |  0.28
Other   |            | 0.005455   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128380 ave      128380 max      128380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128380
Ave neighs/atom = 64.19
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731740526573, Press = -1.30283556084599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8407.4189     -8407.4189     -8490.0732     -8490.0732      319.88043      319.88043      23445.061      23445.061     -2604.0565     -2604.0565    
     22000  -8401.341      -8401.341      -8488.488      -8488.488       337.26807      337.26807      23402.446      23402.446      975.09876      975.09876    
Loop time of 21.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.024 hours/ns, 46.108 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.606     | 21.606     | 21.606     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.07
Output  | 2.9195e-05 | 2.9195e-05 | 2.9195e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.28
Other   |            | 0.005458   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128264 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.569247767043, Press = 5.83170925698693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8401.341      -8401.341      -8488.488      -8488.488       337.26807      337.26807      23402.446      23402.446      975.09876      975.09876    
     23000  -8403.1761     -8403.1761     -8490.6764     -8490.6764      338.6354       338.6354       23374.008      23374.008      2695.8225      2695.8225    
Loop time of 21.8971 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.946 ns/day, 6.083 hours/ns, 45.668 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.815     | 21.815     | 21.815     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01498    | 0.01498    | 0.01498    |   0.0 |  0.07
Output  | 2.9355e-05 | 2.9355e-05 | 2.9355e-05 |   0.0 |  0.00
Modify  | 0.061924   | 0.061924   | 0.061924   |   0.0 |  0.28
Other   |            | 0.005441   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128278 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.562939015543, Press = -2.09953904613417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8403.1761     -8403.1761     -8490.6764     -8490.6764      338.6354       338.6354       23374.008      23374.008      2695.8225      2695.8225    
     24000  -8398.6848     -8398.6848     -8487.4639     -8487.4639      343.58441      343.58441      23430.076      23430.076     -851.11741     -851.11741    
Loop time of 21.8416 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.956 ns/day, 6.067 hours/ns, 45.784 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.759     | 21.759     | 21.759     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014924   | 0.014924   | 0.014924   |   0.0 |  0.07
Output  | 3.9595e-05 | 3.9595e-05 | 3.9595e-05 |   0.0 |  0.00
Modify  | 0.061922   | 0.061922   | 0.061922   |   0.0 |  0.28
Other   |            | 0.005473   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128276 ave      128276 max      128276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128276
Ave neighs/atom = 64.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.612183125698, Press = -2.5198179650261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8398.6848     -8398.6848     -8487.4639     -8487.4639      343.58441      343.58441      23430.076      23430.076     -851.11741     -851.11741    
     25000  -8403.4439     -8403.4439     -8490.5437     -8490.5437      337.08507      337.08507      23431.807      23431.807     -1497.9788     -1497.9788    
Loop time of 21.8246 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.959 ns/day, 6.062 hours/ns, 45.820 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.742     | 21.742     | 21.742     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.07
Output  | 2.8854e-05 | 2.8854e-05 | 2.8854e-05 |   0.0 |  0.00
Modify  | 0.061876   | 0.061876   | 0.061876   |   0.0 |  0.28
Other   |            | 0.005462   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128326 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.708555759763, Press = 1.35738743538747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8403.4439     -8403.4439     -8490.5437     -8490.5437      337.08507      337.08507      23431.807      23431.807     -1497.9788     -1497.9788    
     26000  -8401.653      -8401.653      -8489.962      -8489.962       341.76489      341.76489      23390.892      23390.892      1620.3676      1620.3676    
Loop time of 21.7513 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.972 ns/day, 6.042 hours/ns, 45.974 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.669     | 21.669     | 21.669     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014949   | 0.014949   | 0.014949   |   0.0 |  0.07
Output  | 3.9815e-05 | 3.9815e-05 | 3.9815e-05 |   0.0 |  0.00
Modify  | 0.061903   | 0.061903   | 0.061903   |   0.0 |  0.28
Other   |            | 0.005469   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128238 ave      128238 max      128238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128238
Ave neighs/atom = 64.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.877351043772, Press = 0.723248954166799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8401.653      -8401.653      -8489.962      -8489.962       341.76489      341.76489      23390.892      23390.892      1620.3676      1620.3676    
     27000  -8404.1099     -8404.1099     -8488.8963     -8488.8963      328.13227      328.13227      23413.63       23413.63      -11.180596     -11.180596    
Loop time of 21.7509 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.972 ns/day, 6.042 hours/ns, 45.975 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.669     | 21.669     | 21.669     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014953   | 0.014953   | 0.014953   |   0.0 |  0.07
Output  | 2.9235e-05 | 2.9235e-05 | 2.9235e-05 |   0.0 |  0.00
Modify  | 0.061858   | 0.061858   | 0.061858   |   0.0 |  0.28
Other   |            | 0.005478   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128308 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888381885827, Press = -2.55236615439497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8404.1099     -8404.1099     -8488.8963     -8488.8963      328.13227      328.13227      23413.63       23413.63      -11.180596     -11.180596    
     28000  -8399.8034     -8399.8034     -8486.6323     -8486.6323      336.03651      336.03651      23452.412      23452.412     -2460.0122     -2460.0122    
Loop time of 21.7953 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.964 ns/day, 6.054 hours/ns, 45.881 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.713     | 21.713     | 21.713     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.07
Output  | 3.5076e-05 | 3.5076e-05 | 3.5076e-05 |   0.0 |  0.00
Modify  | 0.061836   | 0.061836   | 0.061836   |   0.0 |  0.28
Other   |            | 0.005463   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128302 ave      128302 max      128302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128302
Ave neighs/atom = 64.151
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9852554691, Press = 1.72553513263835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8399.8034     -8399.8034     -8486.6323     -8486.6323      336.03651      336.03651      23452.412      23452.412     -2460.0122     -2460.0122    
     29000  -8403.8134     -8403.8134     -8488.9537     -8488.9537      329.50154      329.50154      23355.497      23355.497      4138.487       4138.487     
Loop time of 21.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.963 ns/day, 6.056 hours/ns, 45.872 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.718     | 21.718     | 21.718     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.07
Output  | 3.9654e-05 | 3.9654e-05 | 3.9654e-05 |   0.0 |  0.00
Modify  | 0.061975   | 0.061975   | 0.061975   |   0.0 |  0.28
Other   |            | 0.005455   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128326 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.977467672467, Press = 3.07328492000671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8403.8134     -8403.8134     -8488.9537     -8488.9537      329.50154      329.50154      23355.497      23355.497      4138.487       4138.487     
     30000  -8401.574      -8401.574      -8489.3078     -8489.3078      339.53864      339.53864      23410.156      23410.156      235.89323      235.89323    
Loop time of 21.885 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.948 ns/day, 6.079 hours/ns, 45.693 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.803     | 21.803     | 21.803     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.07
Output  | 2.9125e-05 | 2.9125e-05 | 2.9125e-05 |   0.0 |  0.00
Modify  | 0.061859   | 0.061859   | 0.061859   |   0.0 |  0.28
Other   |            | 0.005466   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128352 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9150953709, Press = -3.68506637099109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8401.574      -8401.574      -8489.3078     -8489.3078      339.53864      339.53864      23410.156      23410.156      235.89323      235.89323    
     31000  -8406.4737     -8406.4737     -8490.6991     -8490.6991      325.96091      325.96091      23436.698      23436.698     -2072.108      -2072.108     
Loop time of 21.7977 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.964 ns/day, 6.055 hours/ns, 45.876 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.715     | 21.715     | 21.715     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.07
Output  | 2.9235e-05 | 2.9235e-05 | 2.9235e-05 |   0.0 |  0.00
Modify  | 0.061863   | 0.061863   | 0.061863   |   0.0 |  0.28
Other   |            | 0.005463   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128322 ave      128322 max      128322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128322
Ave neighs/atom = 64.161
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.827668060057, Press = -0.200604869235883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8406.4737     -8406.4737     -8490.6991     -8490.6991      325.96091      325.96091      23436.698      23436.698     -2072.108      -2072.108     
     32000  -8401.8125     -8401.8125     -8489.7136     -8489.7136      340.18662      340.18662      23409.782      23409.782      195.60725      195.60725    
Loop time of 21.8717 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.950 ns/day, 6.075 hours/ns, 45.721 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.789     | 21.789     | 21.789     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.07
Output  | 4.0376e-05 | 4.0376e-05 | 4.0376e-05 |   0.0 |  0.00
Modify  | 0.061875   | 0.061875   | 0.061875   |   0.0 |  0.28
Other   |            | 0.005475   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128292 ave      128292 max      128292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128292
Ave neighs/atom = 64.146
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.791372747666, Press = 1.09583570434745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8401.8125     -8401.8125     -8489.7136     -8489.7136      340.18662      340.18662      23409.782      23409.782      195.60725      195.60725    
     33000  -8403.6119     -8403.6119     -8489.533      -8489.533       332.52363      332.52363      23399.798      23399.798      844.86313      844.86313    
Loop time of 21.8574 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.953 ns/day, 6.071 hours/ns, 45.751 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.775     | 21.775     | 21.775     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.07
Output  | 2.8914e-05 | 2.8914e-05 | 2.8914e-05 |   0.0 |  0.00
Modify  | 0.061861   | 0.061861   | 0.061861   |   0.0 |  0.28
Other   |            | 0.005459   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128278 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.802866316022, Press = -0.411820379998504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8403.6119     -8403.6119     -8489.533      -8489.533       332.52363      332.52363      23399.798      23399.798      844.86313      844.86313    
     34000  -8401.7433     -8401.7433     -8488.1601     -8488.1601      334.44201      334.44201      23429.635      23429.635     -1024.2388     -1024.2388    
Loop time of 21.8621 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.073 hours/ns, 45.741 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.78      | 21.78      | 21.78      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.07
Output  | 2.9214e-05 | 2.9214e-05 | 2.9214e-05 |   0.0 |  0.00
Modify  | 0.061863   | 0.061863   | 0.061863   |   0.0 |  0.28
Other   |            | 0.005465   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128358 ave      128358 max      128358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128358
Ave neighs/atom = 64.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.823018003115, Press = -1.44876730834406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8401.7433     -8401.7433     -8488.1601     -8488.1601      334.44201      334.44201      23429.635      23429.635     -1024.2388     -1024.2388    
     35000  -8405.4467     -8405.4467     -8489.801      -8489.801       326.45982      326.45982      23430.197      23430.197     -1544.7683     -1544.7683    
Loop time of 21.7641 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.970 ns/day, 6.046 hours/ns, 45.947 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.682     | 21.682     | 21.682     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.07
Output  | 4.1348e-05 | 4.1348e-05 | 4.1348e-05 |   0.0 |  0.00
Modify  | 0.061905   | 0.061905   | 0.061905   |   0.0 |  0.28
Other   |            | 0.005468   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128314 ave      128314 max      128314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128314
Ave neighs/atom = 64.157
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.82285980191, Press = 1.8669115980967
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8405.4467     -8405.4467     -8489.801      -8489.801       326.45982      326.45982      23430.197      23430.197     -1544.7683     -1544.7683    
     36000  -8402.5233     -8402.5233     -8487.4275     -8487.4275      328.58779      328.58779      23361.657      23361.657      3880.8277      3880.8277    
Loop time of 21.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.951 ns/day, 6.074 hours/ns, 45.731 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.785     | 21.785     | 21.785     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015038   | 0.015038   | 0.015038   |   0.0 |  0.07
Output  | 2.9015e-05 | 2.9015e-05 | 2.9015e-05 |   0.0 |  0.00
Modify  | 0.061903   | 0.061903   | 0.061903   |   0.0 |  0.28
Other   |            | 0.005452   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128304 ave      128304 max      128304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128304
Ave neighs/atom = 64.152
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.860066113322, Press = 0.758400864042186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8402.5233     -8402.5233     -8487.4275     -8487.4275      328.58779      328.58779      23361.657      23361.657      3880.8277      3880.8277    
     37000  -8404.6755     -8404.6755     -8489.0927     -8489.0927      326.70317      326.70317      23418.974      23418.974     -495.0376      -495.0376     
Loop time of 21.9117 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.943 ns/day, 6.087 hours/ns, 45.638 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.829     | 21.829     | 21.829     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.07
Output  | 3.9073e-05 | 3.9073e-05 | 3.9073e-05 |   0.0 |  0.00
Modify  | 0.06182    | 0.06182    | 0.06182    |   0.0 |  0.28
Other   |            | 0.005464   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128378 ave      128378 max      128378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128378
Ave neighs/atom = 64.189
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.739325381792, Press = -2.22656953020511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8404.6755     -8404.6755     -8489.0927     -8489.0927      326.70317      326.70317      23418.974      23418.974     -495.0376      -495.0376     
     38000  -8402.3785     -8402.3785     -8489.3599     -8489.3599      336.62716      336.62716      23426.639      23426.639     -996.70635     -996.70635    
Loop time of 21.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.951 ns/day, 6.074 hours/ns, 45.733 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.784     | 21.784     | 21.784     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.07
Output  | 2.9556e-05 | 2.9556e-05 | 2.9556e-05 |   0.0 |  0.00
Modify  | 0.061959   | 0.061959   | 0.061959   |   0.0 |  0.28
Other   |            | 0.005467   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128270 ave      128270 max      128270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128270
Ave neighs/atom = 64.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.733793648136, Press = 0.592497297374319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8402.3785     -8402.3785     -8489.3599     -8489.3599      336.62716      336.62716      23426.639      23426.639     -996.70635     -996.70635    
     39000  -8405.3835     -8405.3835     -8487.6649     -8487.6649      318.43757      318.43757      23398.281      23398.281      1049.8294      1049.8294    
Loop time of 21.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.939 ns/day, 6.092 hours/ns, 45.595 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.85      | 21.85      | 21.85      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014976   | 0.014976   | 0.014976   |   0.0 |  0.07
Output  | 2.9025e-05 | 2.9025e-05 | 2.9025e-05 |   0.0 |  0.00
Modify  | 0.061912   | 0.061912   | 0.061912   |   0.0 |  0.28
Other   |            | 0.005461   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128306 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.70294860778, Press = 0.274371279261935
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8405.3835     -8405.3835     -8487.6649     -8487.6649      318.43757      318.43757      23398.281      23398.281      1049.8294      1049.8294    
     40000  -8402.5166     -8402.5166     -8487.552      -8487.552       329.09587      329.09587      23411.087      23411.087      334.32566      334.32566    
Loop time of 21.8956 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.946 ns/day, 6.082 hours/ns, 45.671 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.813     | 21.813     | 21.813     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015014   | 0.015014   | 0.015014   |   0.0 |  0.07
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.061967   | 0.061967   | 0.061967   |   0.0 |  0.28
Other   |            | 0.005463   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128348 ave      128348 max      128348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128348
Ave neighs/atom = 64.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.709627834462, Press = -0.716003665362372
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8402.5166     -8402.5166     -8487.552      -8487.552       329.09587      329.09587      23411.087      23411.087      334.32566      334.32566    
     41000  -8406.9786     -8406.9786     -8491.1973     -8491.1973      325.93494      325.93494      23421.501      23421.501     -1038.2042     -1038.2042    
Loop time of 21.8656 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.951 ns/day, 6.074 hours/ns, 45.734 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.783     | 21.783     | 21.783     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014947   | 0.014947   | 0.014947   |   0.0 |  0.07
Output  | 2.9405e-05 | 2.9405e-05 | 2.9405e-05 |   0.0 |  0.00
Modify  | 0.061855   | 0.061855   | 0.061855   |   0.0 |  0.28
Other   |            | 0.005457   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128308 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.665188976177, Press = 1.28739869315268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8406.9786     -8406.9786     -8491.1973     -8491.1973      325.93494      325.93494      23421.501      23421.501     -1038.2042     -1038.2042    
     42000  -8401.7718     -8401.7718     -8487.6711     -8487.6711      332.43914      332.43914      23367.011      23367.011      3356.1256      3356.1256    
Loop time of 21.7923 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.888 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.71      | 21.71      | 21.71      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.07
Output  | 3.203e-05  | 3.203e-05  | 3.203e-05  |   0.0 |  0.00
Modify  | 0.061799   | 0.061799   | 0.061799   |   0.0 |  0.28
Other   |            | 0.005477   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128256 ave      128256 max      128256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128256
Ave neighs/atom = 64.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.616804091061, Press = 0.595511267307478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8401.7718     -8401.7718     -8487.6711     -8487.6711      332.43914      332.43914      23367.011      23367.011      3356.1256      3356.1256    
     43000  -8399.1734     -8399.1734     -8487.0959     -8487.0959      340.26948      340.26948      23435.747      23435.747     -1329.2568     -1329.2568    
Loop time of 21.9214 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.941 ns/day, 6.089 hours/ns, 45.618 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.839     | 21.839     | 21.839     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.07
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.061947   | 0.061947   | 0.061947   |   0.0 |  0.28
Other   |            | 0.005459   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128364 ave      128364 max      128364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128364
Ave neighs/atom = 64.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.725269434339, Press = -2.39878595245666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8399.1734     -8399.1734     -8487.0959     -8487.0959      340.26948      340.26948      23435.747      23435.747     -1329.2568     -1329.2568    
     44000  -8404.2017     -8404.2017     -8488.4967     -8488.4967      326.23004      326.23004      23422.628      23422.628     -832.02505     -832.02505    
Loop time of 21.9137 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.943 ns/day, 6.087 hours/ns, 45.634 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.831     | 21.831     | 21.831     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.07
Output  | 2.9455e-05 | 2.9455e-05 | 2.9455e-05 |   0.0 |  0.00
Modify  | 0.061948   | 0.061948   | 0.061948   |   0.0 |  0.28
Other   |            | 0.005481   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128292 ave      128292 max      128292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128292
Ave neighs/atom = 64.146
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.749462455509, Press = 1.36354612890034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8404.2017     -8404.2017     -8488.4967     -8488.4967      326.23004      326.23004      23422.628      23422.628     -832.02505     -832.02505    
     45000  -8398.1805     -8398.1805     -8486.3298     -8486.3298      341.14691      341.14691      23394.872      23394.872      1689.6156      1689.6156    
Loop time of 21.7801 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.967 ns/day, 6.050 hours/ns, 45.913 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.698     | 21.698     | 21.698     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015046   | 0.015046   | 0.015046   |   0.0 |  0.07
Output  | 3.0508e-05 | 3.0508e-05 | 3.0508e-05 |   0.0 |  0.00
Modify  | 0.061911   | 0.061911   | 0.061911   |   0.0 |  0.28
Other   |            | 0.005457   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128278 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.833815014718, Press = 0.246840607540069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8398.1805     -8398.1805     -8486.3298     -8486.3298      341.14691      341.14691      23394.872      23394.872      1689.6156      1689.6156    
     46000  -8404.056      -8404.056      -8490.7175     -8490.7175      335.38908      335.38908      23408.561      23408.561     -5.9430691     -5.9430691    
Loop time of 21.8421 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.956 ns/day, 6.067 hours/ns, 45.783 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.76      | 21.76      | 21.76      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.07
Output  | 4.0456e-05 | 4.0456e-05 | 4.0456e-05 |   0.0 |  0.00
Modify  | 0.061945   | 0.061945   | 0.061945   |   0.0 |  0.28
Other   |            | 0.005477   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128358 ave      128358 max      128358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128358
Ave neighs/atom = 64.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.859563036998, Press = -0.697833594207596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8404.056      -8404.056      -8490.7175     -8490.7175      335.38908      335.38908      23408.561      23408.561     -5.9430691     -5.9430691    
     47000  -8402.4582     -8402.4582     -8486.7772     -8486.7772      326.32294      326.32294      23418.002      23418.002     -120.80883     -120.80883    
Loop time of 21.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.955 ns/day, 6.068 hours/ns, 45.779 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.762     | 21.762     | 21.762     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.07
Output  | 2.8824e-05 | 2.8824e-05 | 2.8824e-05 |   0.0 |  0.00
Modify  | 0.061874   | 0.061874   | 0.061874   |   0.0 |  0.28
Other   |            | 0.00546    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128274 ave      128274 max      128274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128274
Ave neighs/atom = 64.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.79944183606, Press = -0.383839461599028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8402.4582     -8402.4582     -8486.7772     -8486.7772      326.32294      326.32294      23418.002      23418.002     -120.80883     -120.80883    
     48000  -8404.7842     -8404.7842     -8489.6663     -8489.6663      328.50269      328.50269      23411.125      23411.125      19.748014      19.748014    
Loop time of 21.8223 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.959 ns/day, 6.062 hours/ns, 45.825 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.74      | 21.74      | 21.74      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.07
Output  | 3.8883e-05 | 3.8883e-05 | 3.8883e-05 |   0.0 |  0.00
Modify  | 0.061896   | 0.061896   | 0.061896   |   0.0 |  0.28
Other   |            | 0.005484   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128280 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.796795388828, Press = -0.414160016344619
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8404.7842     -8404.7842     -8489.6663     -8489.6663      328.50269      328.50269      23411.125      23411.125      19.748014      19.748014    
     49000  -8402.9602     -8402.9602     -8488.7249     -8488.7249      331.91846      331.91846      23408.771      23408.771      357.36228      357.36228    
Loop time of 21.8779 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.949 ns/day, 6.077 hours/ns, 45.708 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.795     | 21.795     | 21.795     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015089   | 0.015089   | 0.015089   |   0.0 |  0.07
Output  | 2.8183e-05 | 2.8183e-05 | 2.8183e-05 |   0.0 |  0.00
Modify  | 0.061952   | 0.061952   | 0.061952   |   0.0 |  0.28
Other   |            | 0.005463   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128276 ave      128276 max      128276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128276
Ave neighs/atom = 64.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.873879073458, Press = 0.0349844932226044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8402.9602     -8402.9602     -8488.7249     -8488.7249      331.91846      331.91846      23408.771      23408.771      357.36228      357.36228    
     50000  -8401.0088     -8401.0088     -8487.0582     -8487.0582      333.02038      333.02038      23408.88       23408.88       593.49148      593.49148    
Loop time of 21.8478 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.955 ns/day, 6.069 hours/ns, 45.771 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.766     | 21.766     | 21.766     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.07
Output  | 2.9886e-05 | 2.9886e-05 | 2.9886e-05 |   0.0 |  0.00
Modify  | 0.061825   | 0.061825   | 0.061825   |   0.0 |  0.28
Other   |            | 0.005478   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128352 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.911936554102, Press = -0.288391826617046
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8401.0088     -8401.0088     -8487.0582     -8487.0582      333.02038      333.02038      23408.88       23408.88       593.49148      593.49148    
     51000  -8404.5186     -8404.5186     -8488.4337     -8488.4337      324.76021      324.76021      23413.37       23413.37      -123.49136     -123.49136    
Loop time of 21.8623 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.073 hours/ns, 45.741 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.78      | 21.78      | 21.78      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014893   | 0.014893   | 0.014893   |   0.0 |  0.07
Output  | 4.1608e-05 | 4.1608e-05 | 4.1608e-05 |   0.0 |  0.00
Modify  | 0.061846   | 0.061846   | 0.061846   |   0.0 |  0.28
Other   |            | 0.005458   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128320 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.962910201723, Press = -0.316992239440878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8404.5186     -8404.5186     -8488.4337     -8488.4337      324.76021      324.76021      23413.37       23413.37      -123.49136     -123.49136    
     52000  -8400.2683     -8400.2683     -8487.8593     -8487.8593      338.98631      338.98631      23419.989      23419.989     -215.10239     -215.10239    
Loop time of 21.8062 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.962 ns/day, 6.057 hours/ns, 45.859 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.724     | 21.724     | 21.724     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.07
Output  | 5.4783e-05 | 5.4783e-05 | 5.4783e-05 |   0.0 |  0.00
Modify  | 0.061878   | 0.061878   | 0.061878   |   0.0 |  0.28
Other   |            | 0.005479   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128244 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.982930203232, Press = -0.333183938745167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8400.2683     -8400.2683     -8487.8593     -8487.8593      338.98631      338.98631      23419.989      23419.989     -215.10239     -215.10239    
     53000  -8404.6503     -8404.6503     -8489.3716     -8489.3716      327.8805       327.8805       23411.564      23411.564      92.621365      92.621365    
Loop time of 21.9177 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.942 ns/day, 6.088 hours/ns, 45.625 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.835     | 21.835     | 21.835     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01498    | 0.01498    | 0.01498    |   0.0 |  0.07
Output  | 2.9566e-05 | 2.9566e-05 | 2.9566e-05 |   0.0 |  0.00
Modify  | 0.061926   | 0.061926   | 0.061926   |   0.0 |  0.28
Other   |            | 0.005458   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128310 ave      128310 max      128310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128310
Ave neighs/atom = 64.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.022015720044, Press = -0.576789668001337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8404.6503     -8404.6503     -8489.3716     -8489.3716      327.8805       327.8805       23411.564      23411.564      92.621365      92.621365    
     54000  -8403.9495     -8403.9495     -8489.6551     -8489.6551      331.68937      331.68937      23416.062      23416.062     -271.56261     -271.56261    
Loop time of 21.8692 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.951 ns/day, 6.075 hours/ns, 45.726 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.787     | 21.787     | 21.787     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.07
Output  | 4.1578e-05 | 4.1578e-05 | 4.1578e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.28
Other   |            | 0.005466   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128318 ave      128318 max      128318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0