# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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  -8514.5882     -8514.5882     -8579.9999     -8579.9999      253.15         253.15         23173.502      23173.502      3014.9739      3014.9739    
      1000  -8445.8864     -8445.8864     -8510.6413     -8510.6413      250.608        250.608        23391.451      23391.451     -2872.3947     -2872.3947    
Loop time of 18.4363 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.686 ns/day, 5.121 hours/ns, 54.241 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    | 18.354     | 18.354     | 18.354     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015357   | 0.015357   | 0.015357   |   0.0 |  0.08
Output  | 0.00015067 | 0.00015067 | 0.00015067 |   0.0 |  0.00
Modify  | 0.060605   | 0.060605   | 0.060605   |   0.0 |  0.33
Other   |            | 0.005785   |            |       |  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  -8445.8864     -8445.8864     -8510.6413     -8510.6413      250.608        250.608        23391.451      23391.451     -2872.3947     -2872.3947    
      2000  -8446.2009     -8446.2009     -8511.519      -8511.519       252.78797      252.78797      23341.463      23341.463      850.46394      850.46394    
Loop time of 20.939 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.126 ns/day, 5.816 hours/ns, 47.758 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    | 20.859     | 20.859     | 20.859     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015021   | 0.015021   | 0.015021   |   0.0 |  0.07
Output  | 4.4253e-05 | 4.4253e-05 | 4.4253e-05 |   0.0 |  0.00
Modify  | 0.059462   | 0.059462   | 0.059462   |   0.0 |  0.28
Other   |            | 0.005398   |            |       |  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:       128088 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8446.2009     -8446.2009     -8511.519      -8511.519       252.78797      252.78797      23341.463      23341.463      850.46394      850.46394    
      3000  -8447.5123     -8447.5123     -8508.4279     -8508.4279      235.74932      235.74932      23344.805      23344.805      772.27522      772.27522    
Loop time of 21.0531 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.104 ns/day, 5.848 hours/ns, 47.499 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    | 20.973     | 20.973     | 20.973     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.07
Output  | 7.463e-05  | 7.463e-05  | 7.463e-05  |   0.0 |  0.00
Modify  | 0.059537   | 0.059537   | 0.059537   |   0.0 |  0.28
Other   |            | 0.00527    |            |       |  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:       128150 ave      128150 max      128150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128150
Ave neighs/atom = 64.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8447.5123     -8447.5123     -8508.4279     -8508.4279      235.74932      235.74932      23344.805      23344.805      772.27522      772.27522    
      4000  -8445.6178     -8445.6178     -8510.4198     -8510.4198      250.79024      250.79024      23340.425      23340.425      952.92416      952.92416    
Loop time of 21.1921 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.077 ns/day, 5.887 hours/ns, 47.187 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.112     | 21.112     | 21.112     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015037   | 0.015037   | 0.015037   |   0.0 |  0.07
Output  | 4.4884e-05 | 4.4884e-05 | 4.4884e-05 |   0.0 |  0.00
Modify  | 0.059383   | 0.059383   | 0.059383   |   0.0 |  0.28
Other   |            | 0.005295   |            |       |  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:       128150 ave      128150 max      128150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128150
Ave neighs/atom = 64.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8445.6178     -8445.6178     -8510.4198     -8510.4198      250.79024      250.79024      23340.425      23340.425      952.92416      952.92416    
      5000  -8447.8692     -8447.8692     -8509.9023     -8509.9023      240.0744       240.0744       23349.255      23349.255      348.78165      348.78165    
Loop time of 21.1479 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.086 ns/day, 5.874 hours/ns, 47.286 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.068     | 21.068     | 21.068     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014879   | 0.014879   | 0.014879   |   0.0 |  0.07
Output  | 3.769e-05  | 3.769e-05  | 3.769e-05  |   0.0 |  0.00
Modify  | 0.059829   | 0.059829   | 0.059829   |   0.0 |  0.28
Other   |            | 0.005405   |            |       |  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:       128110 ave      128110 max      128110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128110
Ave neighs/atom = 64.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 251.461386016861, Press = -811.428309106448
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.8692     -8447.8692     -8509.9023     -8509.9023      240.0744       240.0744       23349.255      23349.255      348.78165      348.78165    
      6000  -8444.2546     -8444.2546     -8510.7771     -8510.7771      257.44888      257.44888      23365.609      23365.609     -870.18379     -870.18379    
Loop time of 21.2341 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.069 ns/day, 5.898 hours/ns, 47.094 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.152     | 21.152     | 21.152     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015077   | 0.015077   | 0.015077   |   0.0 |  0.07
Output  | 2.8043e-05 | 2.8043e-05 | 2.8043e-05 |   0.0 |  0.00
Modify  | 0.061786   | 0.061786   | 0.061786   |   0.0 |  0.29
Other   |            | 0.005411   |            |       |  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:       128162 ave      128162 max      128162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128162
Ave neighs/atom = 64.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.23241286814, Press = 45.4990627125214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8444.2546     -8444.2546     -8510.7771     -8510.7771      257.44888      257.44888      23365.609      23365.609     -870.18379     -870.18379    
      7000  -8446.5224     -8446.5224     -8513.1536     -8513.1536      257.86978      257.86978      23327.805      23327.805      1498.9632      1498.9632    
Loop time of 21.2444 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.067 ns/day, 5.901 hours/ns, 47.071 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.162     | 21.162     | 21.162     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015213   | 0.015213   | 0.015213   |   0.0 |  0.07
Output  | 2.7863e-05 | 2.7863e-05 | 2.7863e-05 |   0.0 |  0.00
Modify  | 0.061842   | 0.061842   | 0.061842   |   0.0 |  0.29
Other   |            | 0.005378   |            |       |  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:       128124 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.78754593453, Press = -39.8020824613256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.5224     -8446.5224     -8513.1536     -8513.1536      257.86978      257.86978      23327.805      23327.805      1498.9632      1498.9632    
      8000  -8445.1168     -8445.1168     -8511.424      -8511.424       256.6157       256.6157       23364.32       23364.32      -888.26759     -888.26759    
Loop time of 21.165 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.082 ns/day, 5.879 hours/ns, 47.248 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.083     | 21.083     | 21.083     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.07
Output  | 3.6338e-05 | 3.6338e-05 | 3.6338e-05 |   0.0 |  0.00
Modify  | 0.061819   | 0.061819   | 0.061819   |   0.0 |  0.29
Other   |            | 0.005383   |            |       |  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:       128102 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.444868547532, Press = -3.00100933771206
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.1168     -8445.1168     -8511.424      -8511.424       256.6157       256.6157       23364.32       23364.32      -888.26759     -888.26759    
      9000  -8448.586      -8448.586      -8512.4551     -8512.4551      247.18008      247.18008      23342.76       23342.76       449.92908      449.92908    
Loop time of 21.1538 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.084 ns/day, 5.876 hours/ns, 47.273 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.072     | 21.072     | 21.072     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.07
Output  | 2.8564e-05 | 2.8564e-05 | 2.8564e-05 |   0.0 |  0.00
Modify  | 0.061848   | 0.061848   | 0.061848   |   0.0 |  0.29
Other   |            | 0.005389   |            |       |  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:       128116 ave      128116 max      128116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128116
Ave neighs/atom = 64.058
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.551786014839, Press = -8.23610220304157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8448.586      -8448.586      -8512.4551     -8512.4551      247.18008      247.18008      23342.76       23342.76       449.92908      449.92908    
     10000  -8444.7126     -8444.7126     -8513.5478     -8513.5478      266.39937      266.39937      23348.755      23348.755      215.90339      215.90339    
Loop time of 21.0737 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.100 ns/day, 5.854 hours/ns, 47.453 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    | 20.991     | 20.991     | 20.991     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01496    | 0.01496    | 0.01496    |   0.0 |  0.07
Output  | 3.219e-05  | 3.219e-05  | 3.219e-05  |   0.0 |  0.00
Modify  | 0.061876   | 0.061876   | 0.061876   |   0.0 |  0.29
Other   |            | 0.005397   |            |       |  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:       128088 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.495183546101, Press = -5.0647041535329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8444.7126     -8444.7126     -8513.5478     -8513.5478      266.39937      266.39937      23348.755      23348.755      215.90339      215.90339    
     11000  -8446.8116     -8446.8116     -8512.1803     -8512.1803      252.98379      252.98379      23337.807      23337.807      948.91719      948.91719    
Loop time of 21.1599 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.083 ns/day, 5.878 hours/ns, 47.259 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.078     | 21.078     | 21.078     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.07
Output  | 2.7932e-05 | 2.7932e-05 | 2.7932e-05 |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.29
Other   |            | 0.005375   |            |       |  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:       128088 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.699006899777, Press = -8.84768516729546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.8116     -8446.8116     -8512.1803     -8512.1803      252.98379      252.98379      23337.807      23337.807      948.91719      948.91719    
     12000  -8449.2305     -8449.2305     -8512.1722     -8512.1722      243.59072      243.59072      23377.88       23377.88      -2133.6507     -2133.6507    
Loop time of 21.1936 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.077 ns/day, 5.887 hours/ns, 47.184 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.111     | 21.111     | 21.111     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.07
Output  | 2.8454e-05 | 2.8454e-05 | 2.8454e-05 |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.29
Other   |            | 0.005315   |            |       |  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:       128102 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.886177912747, Press = 1.74473128982708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8449.2305     -8449.2305     -8512.1722     -8512.1722      243.59072      243.59072      23377.88       23377.88      -2133.6507     -2133.6507    
     13000  -8445.8014     -8445.8014     -8512.1688     -8512.1688      256.84887      256.84887      23320.945      23320.945      2179.2484      2179.2484    
Loop time of 21.1445 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.086 ns/day, 5.873 hours/ns, 47.294 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.062     | 21.062     | 21.062     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015031   | 0.015031   | 0.015031   |   0.0 |  0.07
Output  | 3.6077e-05 | 3.6077e-05 | 3.6077e-05 |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.29
Other   |            | 0.005324   |            |       |  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:       128084 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.773626782295, Press = -8.36858524536006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.8014     -8445.8014     -8512.1688     -8512.1688      256.84887      256.84887      23320.945      23320.945      2179.2484      2179.2484    
     14000  -8448.353      -8448.353      -8512.8374     -8512.8374      249.56112      249.56112      23365.412      23365.412     -1242.5382     -1242.5382    
Loop time of 21.1501 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.085 ns/day, 5.875 hours/ns, 47.281 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.068     | 21.068     | 21.068     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014949   | 0.014949   | 0.014949   |   0.0 |  0.07
Output  | 6.2327e-05 | 6.2327e-05 | 6.2327e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.29
Other   |            | 0.005329   |            |       |  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:       128128 ave      128128 max      128128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128128
Ave neighs/atom = 64.064
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.543016154644, Press = -1.81469638051835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8448.353      -8448.353      -8512.8374     -8512.8374      249.56112      249.56112      23365.412      23365.412     -1242.5382     -1242.5382    
     15000  -8447.519      -8447.519      -8512.4318     -8512.4318      251.21901      251.21901      23335.87       23335.87       946.62795      946.62795    
Loop time of 21.2033 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.075 ns/day, 5.890 hours/ns, 47.162 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.121     | 21.121     | 21.121     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.07
Output  | 2.8483e-05 | 2.8483e-05 | 2.8483e-05 |   0.0 |  0.00
Modify  | 0.061785   | 0.061785   | 0.061785   |   0.0 |  0.29
Other   |            | 0.005317   |            |       |  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:       128102 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.524472197644, Press = -2.22143614297073
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.519      -8447.519      -8512.4318     -8512.4318      251.21901      251.21901      23335.87       23335.87       946.62795      946.62795    
     16000  -8443.6502     -8443.6502     -8510.0911     -8510.0911      257.13304      257.13304      23359.945      23359.945     -364.39784     -364.39784    
Loop time of 21.1884 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.078 ns/day, 5.886 hours/ns, 47.196 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.106     | 21.106     | 21.106     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015113   | 0.015113   | 0.015113   |   0.0 |  0.07
Output  | 3.5837e-05 | 3.5837e-05 | 3.5837e-05 |   0.0 |  0.00
Modify  | 0.061868   | 0.061868   | 0.061868   |   0.0 |  0.29
Other   |            | 0.005348   |            |       |  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:       128122 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.523404733717, Press = -4.34128651639636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8443.6502     -8443.6502     -8510.0911     -8510.0911      257.13304      257.13304      23359.945      23359.945     -364.39784     -364.39784    
     17000  -8447.0483     -8447.0483     -8512.2281     -8512.2281      252.25227      252.25227      23351.274      23351.274     -57.765857     -57.765857    
Loop time of 21.2301 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.070 ns/day, 5.897 hours/ns, 47.103 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.148     | 21.148     | 21.148     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015054   | 0.015054   | 0.015054   |   0.0 |  0.07
Output  | 2.9155e-05 | 2.9155e-05 | 2.9155e-05 |   0.0 |  0.00
Modify  | 0.061753   | 0.061753   | 0.061753   |   0.0 |  0.29
Other   |            | 0.005342   |            |       |  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:       128122 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.665606910452, Press = -0.946854858327776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.0483     -8447.0483     -8512.2281     -8512.2281      252.25227      252.25227      23351.274      23351.274     -57.765857     -57.765857    
     18000  -8444.4386     -8444.4386     -8511.7115     -8511.7115      260.35285      260.35285      23348.793      23348.793      306.00389      306.00389    
Loop time of 21.2685 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.062 ns/day, 5.908 hours/ns, 47.018 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.186     | 21.186     | 21.186     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.07
Output  | 2.8343e-05 | 2.8343e-05 | 2.8343e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.29
Other   |            | 0.005333   |            |       |  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:       128118 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.812385025193, Press = -4.38203701942676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8444.4386     -8444.4386     -8511.7115     -8511.7115      260.35285      260.35285      23348.793      23348.793      306.00389      306.00389    
     19000  -8450.4343     -8450.4343     -8513.6581     -8513.6581      244.6827       244.6827       23360.551      23360.551     -1070.8542     -1070.8542    
Loop time of 21.2401 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.068 ns/day, 5.900 hours/ns, 47.081 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.158     | 21.158     | 21.158     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.07
Output  | 3.5607e-05 | 3.5607e-05 | 3.5607e-05 |   0.0 |  0.00
Modify  | 0.061769   | 0.061769   | 0.061769   |   0.0 |  0.29
Other   |            | 0.005333   |            |       |  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:       128104 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.779103253512, Press = 2.21778834129793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8450.4343     -8450.4343     -8513.6581     -8513.6581      244.6827       244.6827       23360.551      23360.551     -1070.8542     -1070.8542    
     20000  -8446.0389     -8446.0389     -8510.4908     -8510.4908      249.43576      249.43576      23316.711      23316.711      2706.2926      2706.2926    
Loop time of 21.1598 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.083 ns/day, 5.878 hours/ns, 47.259 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.078     | 21.078     | 21.078     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014942   | 0.014942   | 0.014942   |   0.0 |  0.07
Output  | 2.8383e-05 | 2.8383e-05 | 2.8383e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.29
Other   |            | 0.005328   |            |       |  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:       128104 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.697253728235, Press = -6.51212175246684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.0389     -8446.0389     -8510.4908     -8510.4908      249.43576      249.43576      23316.711      23316.711      2706.2926      2706.2926    
     21000  -8449.3653     -8449.3653     -8512.6431     -8512.6431      244.89174      244.89174      23376.299      23376.299     -2010.4245     -2010.4245    
Loop time of 21.1862 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.078 ns/day, 5.885 hours/ns, 47.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.104     | 21.104     | 21.104     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015037   | 0.015037   | 0.015037   |   0.0 |  0.07
Output  | 3.0046e-05 | 3.0046e-05 | 3.0046e-05 |   0.0 |  0.00
Modify  | 0.061765   | 0.061765   | 0.061765   |   0.0 |  0.29
Other   |            | 0.005308   |            |       |  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:       128118 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.601840845604, Press = 0.646702299849891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8449.3653     -8449.3653     -8512.6431     -8512.6431      244.89174      244.89174      23376.299      23376.299     -2010.4245     -2010.4245    
     22000  -8447.7755     -8447.7755     -8513.5464     -8513.5464      254.53994      254.53994      23324.186      23324.186      1698.6307      1698.6307    
Loop time of 21.2308 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.070 ns/day, 5.897 hours/ns, 47.101 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.149     | 21.149     | 21.149     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014944   | 0.014944   | 0.014944   |   0.0 |  0.07
Output  | 3.6018e-05 | 3.6018e-05 | 3.6018e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.29
Other   |            | 0.005358   |            |       |  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:       128118 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.659208603639, Press = -3.23216945631928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.7755     -8447.7755     -8513.5464     -8513.5464      254.53994      254.53994      23324.186      23324.186      1698.6307      1698.6307    
     23000  -8442.8612     -8442.8612     -8509.8266     -8509.8266      259.16313      259.16313      23378.091      23378.091     -1530.338      -1530.338     
Loop time of 21.1681 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.082 ns/day, 5.880 hours/ns, 47.241 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.086     | 21.086     | 21.086     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.07
Output  | 2.9124e-05 | 2.9124e-05 | 2.9124e-05 |   0.0 |  0.00
Modify  | 0.061723   | 0.061723   | 0.061723   |   0.0 |  0.29
Other   |            | 0.005316   |            |       |  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:       128142 ave      128142 max      128142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128142
Ave neighs/atom = 64.071
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.764317480464, Press = -1.67721393817072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8442.8612     -8442.8612     -8509.8266     -8509.8266      259.16313      259.16313      23378.091      23378.091     -1530.338      -1530.338     
     24000  -8447.6672     -8447.6672     -8511.7474     -8511.7474      247.99685      247.99685      23333.644      23333.644      1258.7355      1258.7355    
Loop time of 21.1469 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.086 ns/day, 5.874 hours/ns, 47.288 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.065     | 21.065     | 21.065     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01505    | 0.01505    | 0.01505    |   0.0 |  0.07
Output  | 2.7121e-05 | 2.7121e-05 | 2.7121e-05 |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.29
Other   |            | 0.005348   |            |       |  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:       128098 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.85812820169, Press = -1.1490395826561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.6672     -8447.6672     -8511.7474     -8511.7474      247.99685      247.99685      23333.644      23333.644      1258.7355      1258.7355    
     25000  -8445.5291     -8445.5291     -8511.4446     -8511.4446      255.09975      255.09975      23372.889      23372.889     -1451.3223     -1451.3223    
Loop time of 21.1407 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.087 ns/day, 5.872 hours/ns, 47.302 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.059     | 21.059     | 21.059     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.07
Output  | 3.4405e-05 | 3.4405e-05 | 3.4405e-05 |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.29
Other   |            | 0.005353   |            |       |  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:       128112 ave      128112 max      128112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128112
Ave neighs/atom = 64.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.958683657385, Press = -2.23764949355563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.5291     -8445.5291     -8511.4446     -8511.4446      255.09975      255.09975      23372.889      23372.889     -1451.3223     -1451.3223    
     26000  -8446.2753     -8446.2753     -8511.7897     -8511.7897      253.54728      253.54728      23332.294      23332.294      1398.0413      1398.0413    
Loop time of 21.1239 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.090 ns/day, 5.868 hours/ns, 47.340 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.042     | 21.042     | 21.042     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.07
Output  | 2.8343e-05 | 2.8343e-05 | 2.8343e-05 |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.29
Other   |            | 0.005338   |            |       |  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:       128108 ave      128108 max      128108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128108
Ave neighs/atom = 64.054
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.908081629608, Press = -0.595352516380531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.2753     -8446.2753     -8511.7897     -8511.7897      253.54728      253.54728      23332.294      23332.294      1398.0413      1398.0413    
     27000  -8449.8517     -8449.8517     -8513.4355     -8513.4355      246.07585      246.07585      23374.568      23374.568     -2002.4865     -2002.4865    
Loop time of 21.1027 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.094 ns/day, 5.862 hours/ns, 47.387 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.021     | 21.021     | 21.021     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.07
Output  | 2.8032e-05 | 2.8032e-05 | 2.8032e-05 |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.29
Other   |            | 0.005374   |            |       |  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:       128126 ave      128126 max      128126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128126
Ave neighs/atom = 64.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.894034717001, Press = -3.47201810309657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8449.8517     -8449.8517     -8513.4355     -8513.4355      246.07585      246.07585      23374.568      23374.568     -2002.4865     -2002.4865    
     28000  -8446.4178     -8446.4178     -8511.236      -8511.236       250.85304      250.85304      23328.318      23328.318      1745.4761      1745.4761    
Loop time of 21.1718 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.081 ns/day, 5.881 hours/ns, 47.233 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.09      | 21.09      | 21.09      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015005   | 0.015005   | 0.015005   |   0.0 |  0.07
Output  | 3.752e-05  | 3.752e-05  | 3.752e-05  |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.29
Other   |            | 0.005346   |            |       |  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:       128106 ave      128106 max      128106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128106
Ave neighs/atom = 64.053
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.844174029673, Press = 1.2982299512759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.4178     -8446.4178     -8511.236      -8511.236       250.85304      250.85304      23328.318      23328.318      1745.4761      1745.4761    
     29000  -8446.5711     -8446.5711     -8509.8209     -8509.8209      244.78326      244.78326      23360.802      23360.802     -474.82948     -474.82948    
Loop time of 21.2429 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.067 ns/day, 5.901 hours/ns, 47.075 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.161     | 21.161     | 21.161     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015091   | 0.015091   | 0.015091   |   0.0 |  0.07
Output  | 2.8363e-05 | 2.8363e-05 | 2.8363e-05 |   0.0 |  0.00
Modify  | 0.061736   | 0.061736   | 0.061736   |   0.0 |  0.29
Other   |            | 0.005341   |            |       |  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:       128128 ave      128128 max      128128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128128
Ave neighs/atom = 64.064
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.832356093045, Press = -3.62033054530324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.5711     -8446.5711     -8509.8209     -8509.8209      244.78326      244.78326      23360.802      23360.802     -474.82948     -474.82948    
     30000  -8446.5853     -8446.5853     -8510.3942     -8510.3942      246.94737      246.94737      23354.361      23354.361     -62.288613     -62.288613    
Loop time of 21.1856 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.078 ns/day, 5.885 hours/ns, 47.202 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.103     | 21.103     | 21.103     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.07
Output  | 2.7612e-05 | 2.7612e-05 | 2.7612e-05 |   0.0 |  0.00
Modify  | 0.06171    | 0.06171    | 0.06171    |   0.0 |  0.29
Other   |            | 0.00534    |            |       |  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:       128098 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.868635195796, Press = 0.323286240217179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.5853     -8446.5853     -8510.3942     -8510.3942      246.94737      246.94737      23354.361      23354.361     -62.288613     -62.288613    
     31000  -8448.3381     -8448.3381     -8512.9443     -8512.9443      250.03273      250.03273      23340.837      23340.837      494.25135      494.25135    
Loop time of 21.1301 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.089 ns/day, 5.869 hours/ns, 47.326 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.048     | 21.048     | 21.048     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.07
Output  | 2.8023e-05 | 2.8023e-05 | 2.8023e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.29
Other   |            | 0.005341   |            |       |  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:       128120 ave      128120 max      128120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128120
Ave neighs/atom = 64.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.793482758209, Press = -2.30140271783526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8448.3381     -8448.3381     -8512.9443     -8512.9443      250.03273      250.03273      23340.837      23340.837      494.25135      494.25135    
     32000  -8446.0087     -8446.0087     -8514.1833     -8514.1833      263.84258      263.84258      23364.176      23364.176     -1172.396      -1172.396     
Loop time of 21.1702 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.081 ns/day, 5.881 hours/ns, 47.236 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.088     | 21.088     | 21.088     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01512    | 0.01512    | 0.01512    |   0.0 |  0.07
Output  | 2.7942e-05 | 2.7942e-05 | 2.7942e-05 |   0.0 |  0.00
Modify  | 0.061769   | 0.061769   | 0.061769   |   0.0 |  0.29
Other   |            | 0.005339   |            |       |  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:       128096 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.797461426594, Press = -0.514879059547068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.0087     -8446.0087     -8514.1833     -8514.1833      263.84258      263.84258      23364.176      23364.176     -1172.396      -1172.396     
     33000  -8447.1687     -8447.1687     -8511.9975     -8511.9975      250.8944       250.8944       23337.643      23337.643      938.16798      938.16798    
Loop time of 21.1327 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.088 ns/day, 5.870 hours/ns, 47.320 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.051     | 21.051     | 21.051     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.07
Output  | 3.5347e-05 | 3.5347e-05 | 3.5347e-05 |   0.0 |  0.00
Modify  | 0.06175    | 0.06175    | 0.06175    |   0.0 |  0.29
Other   |            | 0.005359   |            |       |  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:       128074 ave      128074 max      128074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128074
Ave neighs/atom = 64.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.806504349331, Press = -2.01312379089285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.1687     -8447.1687     -8511.9975     -8511.9975      250.8944       250.8944       23337.643      23337.643      938.16798      938.16798    
     34000  -8444.361      -8444.361      -8510.171      -8510.171       254.69136      254.69136      23384.835      23384.835     -2146.9694     -2146.9694    
Loop time of 21.3028 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.056 ns/day, 5.917 hours/ns, 46.942 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.221     | 21.221     | 21.221     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.07
Output  | 2.9626e-05 | 2.9626e-05 | 2.9626e-05 |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.29
Other   |            | 0.005333   |            |       |  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:       128124 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.885623186693, Press = -0.623338182776251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8444.361      -8444.361      -8510.171      -8510.171       254.69136      254.69136      23384.835      23384.835     -2146.9694     -2146.9694    
     35000  -8448.2634     -8448.2634     -8513.2754     -8513.2754      251.60319      251.60319      23289.304      23289.304      4302.7666      4302.7666    
Loop time of 21.2218 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.071 ns/day, 5.895 hours/ns, 47.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.14      | 21.14      | 21.14      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.07
Output  | 2.8624e-05 | 2.8624e-05 | 2.8624e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.29
Other   |            | 0.005319   |            |       |  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:       128096 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.899990225513, Press = -1.20606677242501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8448.2634     -8448.2634     -8513.2754     -8513.2754      251.60319      251.60319      23289.304      23289.304      4302.7666      4302.7666    
     36000  -8445.4848     -8445.4848     -8511.4098     -8511.4098      255.13645      255.13645      23391.993      23391.993     -2833.7594     -2833.7594    
Loop time of 21.1812 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.079 ns/day, 5.884 hours/ns, 47.212 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.099     | 21.099     | 21.099     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.07
Output  | 3.4525e-05 | 3.4525e-05 | 3.4525e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.29
Other   |            | 0.00534    |            |       |  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:       128126 ave      128126 max      128126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128126
Ave neighs/atom = 64.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.869149407229, Press = -1.38365154584592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.4848     -8445.4848     -8511.4098     -8511.4098      255.13645      255.13645      23391.993      23391.993     -2833.7594     -2833.7594    
     37000  -8446.5321     -8446.5321     -8513.6916     -8513.6916      259.91447      259.91447      23321.663      23321.663      2022.9089      2022.9089    
Loop time of 21.1726 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.081 ns/day, 5.881 hours/ns, 47.231 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.091     | 21.091     | 21.091     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014985   | 0.014985   | 0.014985   |   0.0 |  0.07
Output  | 2.7802e-05 | 2.7802e-05 | 2.7802e-05 |   0.0 |  0.00
Modify  | 0.061742   | 0.061742   | 0.061742   |   0.0 |  0.29
Other   |            | 0.005343   |            |       |  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:       128092 ave      128092 max      128092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128092
Ave neighs/atom = 64.046
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.922202042409, Press = -0.734728659628933
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.5321     -8446.5321     -8513.6916     -8513.6916      259.91447      259.91447      23321.663      23321.663      2022.9089      2022.9089    
     38000  -8445.176      -8445.176      -8509.3325     -8509.3325      248.29219      248.29219      23363.779      23363.779     -617.86827     -617.86827    
Loop time of 21.1928 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.077 ns/day, 5.887 hours/ns, 47.186 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.111     | 21.111     | 21.111     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.07
Output  | 2.7942e-05 | 2.7942e-05 | 2.7942e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.29
Other   |            | 0.005327   |            |       |  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:       128114 ave      128114 max      128114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128114
Ave neighs/atom = 64.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.912347266078, Press = -2.03034897251813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.176      -8445.176      -8509.3325     -8509.3325      248.29219      248.29219      23363.779      23363.779     -617.86827     -617.86827    
     39000  -8449.2123     -8449.2123     -8513.4459     -8513.4459      248.59048      248.59048      23345.323      23345.323      221.47321      221.47321    
Loop time of 21.2175 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.072 ns/day, 5.894 hours/ns, 47.131 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.135     | 21.135     | 21.135     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.07
Output  | 3.6438e-05 | 3.6438e-05 | 3.6438e-05 |   0.0 |  0.00
Modify  | 0.06176    | 0.06176    | 0.06176    |   0.0 |  0.29
Other   |            | 0.005333   |            |       |  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:       128094 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.861003140258, Press = 0.498549982730558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8449.2123     -8449.2123     -8513.4459     -8513.4459      248.59048      248.59048      23345.323      23345.323      221.47321      221.47321    
     40000  -8447.7807     -8447.7807     -8512.5615     -8512.5615      250.70858      250.70858      23342.209      23342.209      492.34593      492.34593    
Loop time of 21.2894 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.058 ns/day, 5.914 hours/ns, 46.972 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.207     | 21.207     | 21.207     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.07
Output  | 2.8533e-05 | 2.8533e-05 | 2.8533e-05 |   0.0 |  0.00
Modify  | 0.061638   | 0.061638   | 0.061638   |   0.0 |  0.29
Other   |            | 0.005351   |            |       |  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:       128106 ave      128106 max      128106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128106
Ave neighs/atom = 64.053
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.85380066181, Press = -3.53793652218429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.7807     -8447.7807     -8512.5615     -8512.5615      250.70858      250.70858      23342.209      23342.209      492.34593      492.34593    
     41000  -8442.2056     -8442.2056     -8509.9412     -8509.9412      262.14358      262.14358      23390.486      23390.486     -2399.8261     -2399.8261    
Loop time of 21.2461 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.067 ns/day, 5.902 hours/ns, 47.068 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.164     | 21.164     | 21.164     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015079   | 0.015079   | 0.015079   |   0.0 |  0.07
Output  | 2.8062e-05 | 2.8062e-05 | 2.8062e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.29
Other   |            | 0.005337   |            |       |  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:       128110 ave      128110 max      128110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128110
Ave neighs/atom = 64.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.883540253558, Press = 2.08728274682773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8442.2056     -8442.2056     -8509.9412     -8509.9412      262.14358      262.14358      23390.486      23390.486     -2399.8261     -2399.8261    
     42000  -8447.1049     -8447.1049     -8510.546      -8510.546       245.52371      245.52371      23331.793      23331.793      1578.3662      1578.3662    
Loop time of 21.3605 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.045 ns/day, 5.933 hours/ns, 46.815 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.278     | 21.278     | 21.278     |   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.5777e-05 | 3.5777e-05 | 3.5777e-05 |   0.0 |  0.00
Modify  | 0.061775   | 0.061775   | 0.061775   |   0.0 |  0.29
Other   |            | 0.005346   |            |       |  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:       128120 ave      128120 max      128120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128120
Ave neighs/atom = 64.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.950791745427, Press = -1.22081481111384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.1049     -8447.1049     -8510.546      -8510.546       245.52371      245.52371      23331.793      23331.793      1578.3662      1578.3662    
     43000  -8442.8149     -8442.8149     -8509.2059     -8509.2059      256.93992      256.93992      23375.664      23375.664     -1304.1924     -1304.1924    
Loop time of 21.1967 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.076 ns/day, 5.888 hours/ns, 47.177 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.115     | 21.115     | 21.115     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015037   | 0.015037   | 0.015037   |   0.0 |  0.07
Output  | 2.8163e-05 | 2.8163e-05 | 2.8163e-05 |   0.0 |  0.00
Modify  | 0.061737   | 0.061737   | 0.061737   |   0.0 |  0.29
Other   |            | 0.005336   |            |       |  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:       128130 ave      128130 max      128130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128130
Ave neighs/atom = 64.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.998833885425, Press = -0.454083443701228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8442.8149     -8442.8149     -8509.2059     -8509.2059      256.93992      256.93992      23375.664      23375.664     -1304.1924     -1304.1924    
     44000  -8446.4894     -8446.4894     -8512.3103     -8512.3103      254.73404      254.73404      23334.4        23334.4        1181.2825      1181.2825    
Loop time of 21.1856 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.078 ns/day, 5.885 hours/ns, 47.202 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.104     | 21.104     | 21.104     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.07
Output  | 2.8283e-05 | 2.8283e-05 | 2.8283e-05 |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.29
Other   |            | 0.005326   |            |       |  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:       128070 ave      128070 max      128070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128070
Ave neighs/atom = 64.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.00529240618, Press = -0.258535640758299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.4894     -8446.4894     -8512.3103     -8512.3103      254.73404      254.73404      23334.4        23334.4        1181.2825      1181.2825    
     45000  -8445.0507     -8445.0507     -8510.7683     -8510.7683      254.33425      254.33425      23382.843      23382.843     -2070.3007     -2070.3007    
Loop time of 21.2836 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.059 ns/day, 5.912 hours/ns, 46.985 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.201     | 21.201     | 21.201     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.07
Output  | 3.75e-05   | 3.75e-05   | 3.75e-05   |   0.0 |  0.00
Modify  | 0.061738   | 0.061738   | 0.061738   |   0.0 |  0.29
Other   |            | 0.005352   |            |       |  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:       128104 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.949452806093, Press = -2.10621499586857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.0507     -8445.0507     -8510.7683     -8510.7683      254.33425      254.33425      23382.843      23382.843     -2070.3007     -2070.3007    
     46000  -8445.4019     -8445.4019     -8511.9259     -8511.9259      257.45466      257.45466      23325.997      23325.997      2002.3532      2002.3532    
Loop time of 21.1714 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.081 ns/day, 5.881 hours/ns, 47.234 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.089     | 21.089     | 21.089     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015152   | 0.015152   | 0.015152   |   0.0 |  0.07
Output  | 2.9115e-05 | 2.9115e-05 | 2.9115e-05 |   0.0 |  0.00
Modify  | 0.061685   | 0.061685   | 0.061685   |   0.0 |  0.29
Other   |            | 0.005353   |            |       |  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:       128094 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.947151749006, Press = 1.25913648782265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.4019     -8445.4019     -8511.9259     -8511.9259      257.45466      257.45466      23325.997      23325.997      2002.3532      2002.3532    
     47000  -8446.7031     -8446.7031     -8511.9282     -8511.9282      252.4278       252.4278       23364.73       23364.73      -1066.5957     -1066.5957    
Loop time of 21.2171 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.072 ns/day, 5.894 hours/ns, 47.132 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.135     | 21.135     | 21.135     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.07
Output  | 2.7732e-05 | 2.7732e-05 | 2.7732e-05 |   0.0 |  0.00
Modify  | 0.061749   | 0.061749   | 0.061749   |   0.0 |  0.29
Other   |            | 0.005345   |            |       |  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:       128122 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.965743223908, Press = -1.99138112529366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8446.7031     -8446.7031     -8511.9282     -8511.9282      252.4278       252.4278       23364.73       23364.73      -1066.5957     -1066.5957    
     48000  -8448.192      -8448.192      -8512.2214     -8512.2214      247.80021      247.80021      23345.625      23345.625      314.0497       314.0497     
Loop time of 21.2477 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.066 ns/day, 5.902 hours/ns, 47.064 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.166     | 21.166     | 21.166     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.07
Output  | 2.9215e-05 | 2.9215e-05 | 2.9215e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.29
Other   |            | 0.005341   |            |       |  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:       128112 ave      128112 max      128112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128112
Ave neighs/atom = 64.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.904891587267, Press = 0.148803069074333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8448.192      -8448.192      -8512.2214     -8512.2214      247.80021      247.80021      23345.625      23345.625      314.0497       314.0497     
     49000  -8445.7579     -8445.7579     -8511.4276     -8511.4276      254.14884      254.14884      23345.422      23345.422      498.52373      498.52373    
Loop time of 21.2136 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.073 ns/day, 5.893 hours/ns, 47.139 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.132     | 21.132     | 21.132     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.07
Output  | 2.7902e-05 | 2.7902e-05 | 2.7902e-05 |   0.0 |  0.00
Modify  | 0.0617     | 0.0617     | 0.0617     |   0.0 |  0.29
Other   |            | 0.005346   |            |       |  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:       128116 ave      128116 max      128116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128116
Ave neighs/atom = 64.058
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.905731022722, Press = -1.56170024235244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8445.7579     -8445.7579     -8511.4276     -8511.4276      254.14884      254.14884      23345.422      23345.422      498.52373      498.52373    
     50000  -8443.704      -8443.704      -8510.2524     -8510.2524      257.54914      257.54914      23370.378      23370.378     -1117.0582     -1117.0582    
Loop time of 21.3798 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.041 ns/day, 5.939 hours/ns, 46.773 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.298     | 21.298     | 21.298     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015088   | 0.015088   | 0.015088   |   0.0 |  0.07
Output  | 3.9544e-05 | 3.9544e-05 | 3.9544e-05 |   0.0 |  0.00
Modify  | 0.061717   | 0.061717   | 0.061717   |   0.0 |  0.29
Other   |            | 0.005344   |            |       |  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:       128124 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.909541276657, Press = -0.199569797558416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8443.704      -8443.704      -8510.2524     -8510.2524      257.54914      257.54914      23370.378      23370.378     -1117.0582     -1117.0582    
     51000  -8447.1751     -8447.1751     -8513.5794     -8513.5794      256.99174      256.99174      23321.411      23321.411      1889.9583      1889.9583    
Loop time of 21.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.053 ns/day, 5.922 hours/ns, 46.909 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.236     | 21.236     | 21.236     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01506    | 0.01506    | 0.01506    |   0.0 |  0.07
Output  | 2.8613e-05 | 2.8613e-05 | 2.8613e-05 |   0.0 |  0.00
Modify  | 0.061738   | 0.061738   | 0.061738   |   0.0 |  0.29
Other   |            | 0.005328   |            |       |  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:       128134 ave      128134 max      128134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128134
Ave neighs/atom = 64.067
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.960526965872, Press = -1.14430212239338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -8447.1751     -8447.1751     -8513.5794     -8513.5794      256.99174      256.99174      23321.411      23321.411      1889.9583      1889.9583    
     52000  -8447.8683     -8447.8683     -8512.2766     -8512.2766      249.26678      249.26678      23396.384      23396.384     -3408.3379     -3408.3379    
Loop time of 21.3238 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.052 ns/day, 5.923 hours/ns, 46.896 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.241     | 21.241     | 21.241     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015141   | 0.015141   | 0.015141   |   0.0 |  0.07
Output  | 5.1526e-05 | 5.1526e-05 | 5.1526e-05 |   0.0 |  0.00
Modify  | 0.061772   | 0.061772   | 0.061772   |   0.0 |  0.29
Other   |            | 0.005307   |            |       |  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:       128078 ave      128078 max      128078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128078
Ave neighs/atom = 64.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
23351.1787517285

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0