# 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.850997865200043*${_u_distance}
variable latticeconst_converted equal 2.850997865200043*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85099786520004
Lattice spacing in x,y,z = 2.8509979 2.8509979 2.8509979
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.509979 28.509979 28.509979)
  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.509979 28.509979 28.509979)
  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_LiyanageKimHouze_2014_FeC__MO_075279800195_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.4489947895    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.4489947895/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.4489947895/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.4489947895/(1*1*${_u_distance})
variable      V0_metal equal 23173.4489947895/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23173.4489947895*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.4489947895 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_075279800195_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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8484.2518     -8484.2518     -8559.9991     -8559.9991      293.15         293.15         23173.449      23173.449      3491.3772      3491.3772    
      1000  -8414.8061     -8414.8061     -8492.7091     -8492.7091      301.49266      301.49266      23458.906      23458.906      555.2828       555.2828     
Loop time of 22.3068 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.873 ns/day, 6.196 hours/ns, 44.829 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    | 22.226     | 22.226     | 22.226     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01496    | 0.01496    | 0.01496    |   0.0 |  0.07
Output  | 0.00014625 | 0.00014625 | 0.00014625 |   0.0 |  0.00
Modify  | 0.05982    | 0.05982    | 0.05982    |   0.0 |  0.27
Other   |            | 0.005578   |            |       |  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:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8414.8061     -8414.8061     -8492.7091     -8492.7091      301.49266      301.49266      23458.906      23458.906      555.2828       555.2828     
      2000  -8409.3479     -8409.3479     -8485.1555     -8485.1555      293.38336      293.38336      23498.237      23498.237     -473.43825     -473.43825    
Loop time of 23.2972 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.709 ns/day, 6.471 hours/ns, 42.924 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    | 23.217     | 23.217     | 23.217     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014864   | 0.014864   | 0.014864   |   0.0 |  0.06
Output  | 3.6408e-05 | 3.6408e-05 | 3.6408e-05 |   0.0 |  0.00
Modify  | 0.059337   | 0.059337   | 0.059337   |   0.0 |  0.25
Other   |            | 0.005459   |            |       |  0.02

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

Total # of neighbors = 216424
Ave neighs/atom = 108.212
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8409.3479     -8409.3479     -8485.1555     -8485.1555      293.38336      293.38336      23498.237      23498.237     -473.43825     -473.43825    
      3000  -8415.3215     -8415.3215     -8488.9348     -8488.9348      284.89111      284.89111      23483.572      23483.572     -409.65189     -409.65189    
Loop time of 23.2909 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.710 ns/day, 6.470 hours/ns, 42.935 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    | 23.211     | 23.211     | 23.211     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014897   | 0.014897   | 0.014897   |   0.0 |  0.06
Output  | 3.5987e-05 | 3.5987e-05 | 3.5987e-05 |   0.0 |  0.00
Modify  | 0.059533   | 0.059533   | 0.059533   |   0.0 |  0.26
Other   |            | 0.00542    |            |       |  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:       215206 ave      215206 max      215206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215206
Ave neighs/atom = 107.603
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8415.3215     -8415.3215     -8488.9348     -8488.9348      284.89111      284.89111      23483.572      23483.572     -409.65189     -409.65189    
      4000  -8410.6479     -8410.6479     -8485.8524     -8485.8524      291.04903      291.04903      23471.51       23471.51       1513.8834      1513.8834    
Loop time of 23.2754 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.712 ns/day, 6.465 hours/ns, 42.964 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    | 23.196     | 23.196     | 23.196     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014899   | 0.014899   | 0.014899   |   0.0 |  0.06
Output  | 3.6669e-05 | 3.6669e-05 | 3.6669e-05 |   0.0 |  0.00
Modify  | 0.059356   | 0.059356   | 0.059356   |   0.0 |  0.26
Other   |            | 0.005402   |            |       |  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:       215758 ave      215758 max      215758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215758
Ave neighs/atom = 107.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8410.6479     -8410.6479     -8485.8524     -8485.8524      291.04903      291.04903      23471.51       23471.51       1513.8834      1513.8834    
      5000  -8412.6457     -8412.6457     -8486.7817     -8486.7817      286.91381      286.91381      23475.513      23475.513      958.37021      958.37021    
Loop time of 23.32 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.882 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    | 23.24      | 23.24      | 23.24      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015156   | 0.015156   | 0.015156   |   0.0 |  0.06
Output  | 2.8914e-05 | 2.8914e-05 | 2.8914e-05 |   0.0 |  0.00
Modify  | 0.059713   | 0.059713   | 0.059713   |   0.0 |  0.26
Other   |            | 0.005426   |            |       |  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:       215638 ave      215638 max      215638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215638
Ave neighs/atom = 107.819
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 287.907621343, Press = 896.428235171078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8412.6457     -8412.6457     -8486.7817     -8486.7817      286.91381      286.91381      23475.513      23475.513      958.37021      958.37021    
      6000  -8416.3003     -8416.3003     -8489.0959     -8489.0959      281.72655      281.72655      23513.75       23513.75      -2847.7341     -2847.7341    
Loop time of 23.2865 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.710 ns/day, 6.468 hours/ns, 42.943 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    | 23.204     | 23.204     | 23.204     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014847   | 0.014847   | 0.014847   |   0.0 |  0.06
Output  | 2.162e-05  | 2.162e-05  | 2.162e-05  |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.27
Other   |            | 0.00543    |            |       |  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:       215902 ave      215902 max      215902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215902
Ave neighs/atom = 107.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.899094603768, Press = 58.3000747935183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8416.3003     -8416.3003     -8489.0959     -8489.0959      281.72655      281.72655      23513.75       23513.75      -2847.7341     -2847.7341    
      7000  -8411.1738     -8411.1738     -8485.2779     -8485.2779      286.79043      286.79043      23513.957      23513.957     -1341.7611     -1341.7611    
Loop time of 23.3129 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.895 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    | 23.231     | 23.231     | 23.231     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.06
Output  | 2.9755e-05 | 2.9755e-05 | 2.9755e-05 |   0.0 |  0.00
Modify  | 0.06174    | 0.06174    | 0.06174    |   0.0 |  0.26
Other   |            | 0.005422   |            |       |  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:       215392 ave      215392 max      215392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215392
Ave neighs/atom = 107.696
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.387908812698, Press = -15.1733440954667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8411.1738     -8411.1738     -8485.2779     -8485.2779      286.79043      286.79043      23513.957      23513.957     -1341.7611     -1341.7611    
      8000  -8411.5122     -8411.5122     -8487.0601     -8487.0601      292.37827      292.37827      23472.615      23472.615      1065.9906      1065.9906    
Loop time of 23.3224 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.877 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    | 23.241     | 23.241     | 23.241     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014766   | 0.014766   | 0.014766   |   0.0 |  0.06
Output  | 2.1681e-05 | 2.1681e-05 | 2.1681e-05 |   0.0 |  0.00
Modify  | 0.06163    | 0.06163    | 0.06163    |   0.0 |  0.26
Other   |            | 0.005413   |            |       |  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:       215534 ave      215534 max      215534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215534
Ave neighs/atom = 107.767
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.382512216973, Press = -6.1228245566509
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8411.5122     -8411.5122     -8487.0601     -8487.0601      292.37827      292.37827      23472.615      23472.615      1065.9906      1065.9906    
      9000  -8410.8651     -8410.8651     -8488.8234     -8488.8234      301.70655      301.70655      23470.957      23470.957      1012.4286      1012.4286    
Loop time of 23.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.489 hours/ns, 42.808 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    | 23.278     | 23.278     | 23.278     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01485    | 0.01485    | 0.01485    |   0.0 |  0.06
Output  | 3.1048e-05 | 3.1048e-05 | 3.1048e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.26
Other   |            | 0.005431   |            |       |  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:       216058 ave      216058 max      216058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216058
Ave neighs/atom = 108.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.650789351739, Press = 3.38277465407432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8410.8651     -8410.8651     -8488.8234     -8488.8234      301.70655      301.70655      23470.957      23470.957      1012.4286      1012.4286    
     10000  -8410.549      -8410.549      -8486.2526     -8486.2526      292.98092      292.98092      23471.843      23471.843      1616.7559      1616.7559    
Loop time of 23.3773 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.494 hours/ns, 42.776 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    | 23.295     | 23.295     | 23.295     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014807   | 0.014807   | 0.014807   |   0.0 |  0.06
Output  | 2.144e-05  | 2.144e-05  | 2.144e-05  |   0.0 |  0.00
Modify  | 0.061634   | 0.061634   | 0.061634   |   0.0 |  0.26
Other   |            | 0.005413   |            |       |  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:       216372 ave      216372 max      216372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216372
Ave neighs/atom = 108.186
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820333140498, Press = 4.21489775932909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8410.549      -8410.549      -8486.2526     -8486.2526      292.98092      292.98092      23471.843      23471.843      1616.7559      1616.7559    
     11000  -8412.641      -8412.641      -8488.7158     -8488.7158      294.41731      294.41731      23454.719      23454.719      2040.9208      2040.9208    
Loop time of 23.3912 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.694 ns/day, 6.498 hours/ns, 42.751 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.309     | 23.309     | 23.309     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014803   | 0.014803   | 0.014803   |   0.0 |  0.06
Output  | 2.1751e-05 | 2.1751e-05 | 2.1751e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.26
Other   |            | 0.005436   |            |       |  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:       216204 ave      216204 max      216204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216204
Ave neighs/atom = 108.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.421762191022, Press = 7.33102953672003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8412.641      -8412.641      -8488.7158     -8488.7158      294.41731      294.41731      23454.719      23454.719      2040.9208      2040.9208    
     12000  -8409.2079     -8409.2079     -8487.1749     -8487.1749      301.74058      301.74058      23472.748      23472.748      1223.9169      1223.9169    
Loop time of 23.3699 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.697 ns/day, 6.492 hours/ns, 42.790 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    | 23.288     | 23.288     | 23.288     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014944   | 0.014944   | 0.014944   |   0.0 |  0.06
Output  | 3.0978e-05 | 3.0978e-05 | 3.0978e-05 |   0.0 |  0.00
Modify  | 0.061649   | 0.061649   | 0.061649   |   0.0 |  0.26
Other   |            | 0.00544    |            |       |  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:       216124 ave      216124 max      216124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216124
Ave neighs/atom = 108.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 = 293.411312756895, Press = 15.6605427187185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8409.2079     -8409.2079     -8487.1749     -8487.1749      301.74058      301.74058      23472.748      23472.748      1223.9169      1223.9169    
     13000  -8412.8861     -8412.8861     -8488.5521     -8488.5521      292.83508      292.83508      23516.919      23516.919     -2584.6711     -2584.6711    
Loop time of 23.3533 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.487 hours/ns, 42.821 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    | 23.271     | 23.271     | 23.271     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.06
Output  | 2.1711e-05 | 2.1711e-05 | 2.1711e-05 |   0.0 |  0.00
Modify  | 0.06177    | 0.06177    | 0.06177    |   0.0 |  0.26
Other   |            | 0.005421   |            |       |  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:       215966 ave      215966 max      215966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215966
Ave neighs/atom = 107.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.546410600227, Press = 10.758331912825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8412.8861     -8412.8861     -8488.5521     -8488.5521      292.83508      292.83508      23516.919      23516.919     -2584.6711     -2584.6711    
     14000  -8410.9578     -8410.9578     -8486.7587     -8486.7587      293.35731      293.35731      23515.012      23515.012     -1888.9155     -1888.9155    
Loop time of 23.3755 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.493 hours/ns, 42.780 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    | 23.294     | 23.294     | 23.294     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014815   | 0.014815   | 0.014815   |   0.0 |  0.06
Output  | 3.1009e-05 | 3.1009e-05 | 3.1009e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.26
Other   |            | 0.005414   |            |       |  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:       215536 ave      215536 max      215536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215536
Ave neighs/atom = 107.768
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.657279619957, Press = 0.918556791877342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8410.9578     -8410.9578     -8486.7587     -8486.7587      293.35731      293.35731      23515.012      23515.012     -1888.9155     -1888.9155    
     15000  -8414.2839     -8414.2839     -8489.4727     -8489.4727      290.98867      290.98867      23481.173      23481.173     -123.55224     -123.55224    
Loop time of 23.3317 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.481 hours/ns, 42.860 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    | 23.25      | 23.25      | 23.25      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014899   | 0.014899   | 0.014899   |   0.0 |  0.06
Output  | 2.139e-05  | 2.139e-05  | 2.139e-05  |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.26
Other   |            | 0.005449   |            |       |  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:       215390 ave      215390 max      215390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215390
Ave neighs/atom = 107.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.581667483176, Press = -0.226499304223944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8414.2839     -8414.2839     -8489.4727     -8489.4727      290.98867      290.98867      23481.173      23481.173     -123.55224     -123.55224    
     16000  -8410.3462     -8410.3462     -8486.0766     -8486.0766      293.08421      293.08421      23471.956      23471.956      1425.3068      1425.3068    
Loop time of 23.3512 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.486 hours/ns, 42.824 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    | 23.269     | 23.269     | 23.269     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014838   | 0.014838   | 0.014838   |   0.0 |  0.06
Output  | 2.158e-05  | 2.158e-05  | 2.158e-05  |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.26
Other   |            | 0.005424   |            |       |  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:       216104 ave      216104 max      216104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216104
Ave neighs/atom = 108.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 = 293.390672636628, Press = 2.18112283764228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8410.3462     -8410.3462     -8486.0766     -8486.0766      293.08421      293.08421      23471.956      23471.956      1425.3068      1425.3068    
     17000  -8408.2702     -8408.2702     -8487.3716     -8487.3716      306.13051      306.13051      23484.64       23484.64       345.96648      345.96648    
Loop time of 23.3179 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.886 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.236     | 23.236     | 23.236     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014846   | 0.014846   | 0.014846   |   0.0 |  0.06
Output  | 2.9826e-05 | 2.9826e-05 | 2.9826e-05 |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.26
Other   |            | 0.005446   |            |       |  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:       215878 ave      215878 max      215878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215878
Ave neighs/atom = 107.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.400934391473, Press = 4.50034678760473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8408.2702     -8408.2702     -8487.3716     -8487.3716      306.13051      306.13051      23484.64       23484.64       345.96648      345.96648    
     18000  -8413.0859     -8413.0859     -8486.7476     -8486.7476      285.07836      285.07836      23490.168      23490.168     -244.22848     -244.22848    
Loop time of 23.3771 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.494 hours/ns, 42.777 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    | 23.295     | 23.295     | 23.295     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.06
Output  | 2.152e-05  | 2.152e-05  | 2.152e-05  |   0.0 |  0.00
Modify  | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.26
Other   |            | 0.005446   |            |       |  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:       215942 ave      215942 max      215942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215942
Ave neighs/atom = 107.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.572451709422, Press = 7.34462488892259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8413.0859     -8413.0859     -8486.7476     -8486.7476      285.07836      285.07836      23490.168      23490.168     -244.22848     -244.22848    
     19000  -8409.5007     -8409.5007     -8486.4074     -8486.4074      297.63687      297.63687      23531.08       23531.08      -3165.9996     -3165.9996    
Loop time of 23.3389 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.847 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    | 23.257     | 23.257     | 23.257     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014893   | 0.014893   | 0.014893   |   0.0 |  0.06
Output  | 2.9255e-05 | 2.9255e-05 | 2.9255e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.26
Other   |            | 0.005432   |            |       |  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:       215626 ave      215626 max      215626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215626
Ave neighs/atom = 107.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.647881285193, Press = 1.64032052237525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8409.5007     -8409.5007     -8486.4074     -8486.4074      297.63687      297.63687      23531.08       23531.08      -3165.9996     -3165.9996    
     20000  -8414.16       -8414.16       -8488.2666     -8488.2666      286.8005       286.8005       23491.468      23491.468     -871.11798     -871.11798    
Loop time of 23.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.845 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.258     | 23.258     | 23.258     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.06
Output  | 2.1921e-05 | 2.1921e-05 | 2.1921e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.26
Other   |            | 0.005436   |            |       |  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:       214874 ave      214874 max      214874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214874
Ave neighs/atom = 107.437
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.684148182789, Press = -1.77134329820709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8414.16       -8414.16       -8488.2666     -8488.2666      286.8005       286.8005       23491.468      23491.468     -871.11798     -871.11798    
     21000  -8411.9949     -8411.9949     -8488.0398     -8488.0398      294.30151      294.30151      23469.619      23469.619      1028.2323      1028.2323    
Loop time of 23.3214 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.879 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.24      | 23.24      | 23.24      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014827   | 0.014827   | 0.014827   |   0.0 |  0.06
Output  | 2.1761e-05 | 2.1761e-05 | 2.1761e-05 |   0.0 |  0.00
Modify  | 0.061592   | 0.061592   | 0.061592   |   0.0 |  0.26
Other   |            | 0.005427   |            |       |  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:       215594 ave      215594 max      215594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215594
Ave neighs/atom = 107.797
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.822653085369, Press = 0.295764016263007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8411.9949     -8411.9949     -8488.0398     -8488.0398      294.30151      294.30151      23469.619      23469.619      1028.2323      1028.2323    
     22000  -8410.7063     -8410.7063     -8486.4066     -8486.4066      292.96799      292.96799      23468.226      23468.226      1564.6544      1564.6544    
Loop time of 23.3157 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.477 hours/ns, 42.890 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.234     | 23.234     | 23.234     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014898   | 0.014898   | 0.014898   |   0.0 |  0.06
Output  | 3.3763e-05 | 3.3763e-05 | 3.3763e-05 |   0.0 |  0.00
Modify  | 0.061697   | 0.061697   | 0.061697   |   0.0 |  0.26
Other   |            | 0.00547    |            |       |  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:       215968 ave      215968 max      215968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215968
Ave neighs/atom = 107.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.839069705442, Press = 3.30691527472999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8410.7063     -8410.7063     -8486.4066     -8486.4066      292.96799      292.96799      23468.226      23468.226      1564.6544      1564.6544    
     23000  -8414.0551     -8414.0551     -8490.3778     -8490.3778      295.37688      295.37688      23484.089      23484.089     -475.80371     -475.80371    
Loop time of 23.3567 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.488 hours/ns, 42.814 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.275     | 23.275     | 23.275     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014917   | 0.014917   | 0.014917   |   0.0 |  0.06
Output  | 2.1571e-05 | 2.1571e-05 | 2.1571e-05 |   0.0 |  0.00
Modify  | 0.061785   | 0.061785   | 0.061785   |   0.0 |  0.26
Other   |            | 0.005458   |            |       |  0.02

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

Total # of neighbors = 216030
Ave neighs/atom = 108.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.948465663518, Press = 3.03464394672418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8414.0551     -8414.0551     -8490.3778     -8490.3778      295.37688      295.37688      23484.089      23484.089     -475.80371     -475.80371    
     24000  -8409.6411     -8409.6411     -8485.4941     -8485.4941      293.55922      293.55922      23501.974      23501.974     -657.56555     -657.56555    
Loop time of 23.3747 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.493 hours/ns, 42.781 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.293     | 23.293     | 23.293     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014836   | 0.014836   | 0.014836   |   0.0 |  0.06
Output  | 2.8022e-05 | 2.8022e-05 | 2.8022e-05 |   0.0 |  0.00
Modify  | 0.061713   | 0.061713   | 0.061713   |   0.0 |  0.26
Other   |            | 0.005462   |            |       |  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:       216146 ave      216146 max      216146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216146
Ave neighs/atom = 108.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.952047086275, Press = 1.36499158053266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8409.6411     -8409.6411     -8485.4941     -8485.4941      293.55922      293.55922      23501.974      23501.974     -657.56555     -657.56555    
     25000  -8412.8577     -8412.8577     -8489.224      -8489.224       295.54557      295.54557      23491.385      23491.385     -645.03055     -645.03055    
Loop time of 23.4042 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.692 ns/day, 6.501 hours/ns, 42.727 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.322     | 23.322     | 23.322     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014834   | 0.014834   | 0.014834   |   0.0 |  0.06
Output  | 2.1951e-05 | 2.1951e-05 | 2.1951e-05 |   0.0 |  0.00
Modify  | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.26
Other   |            | 0.005461   |            |       |  0.02

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

Total # of neighbors = 215550
Ave neighs/atom = 107.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.925845497794, Press = 0.212446919604017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8412.8577     -8412.8577     -8489.224      -8489.224       295.54557      295.54557      23491.385      23491.385     -645.03055     -645.03055    
     26000  -8411.1768     -8411.1768     -8486.8247     -8486.8247      292.76505      292.76505      23484.459      23484.459      396.63347      396.63347    
Loop time of 23.3456 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.701 ns/day, 6.485 hours/ns, 42.835 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.264     | 23.264     | 23.264     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014829   | 0.014829   | 0.014829   |   0.0 |  0.06
Output  | 2.151e-05  | 2.151e-05  | 2.151e-05  |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.26
Other   |            | 0.005451   |            |       |  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:       216018 ave      216018 max      216018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216018
Ave neighs/atom = 108.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.830615241459, Press = 0.83549804705627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8411.1768     -8411.1768     -8486.8247     -8486.8247      292.76505      292.76505      23484.459      23484.459      396.63347      396.63347    
     27000  -8417.9183     -8417.9183     -8491.3151     -8491.3151      284.05322      284.05322      23461.328      23461.328      698.52673      698.52673    
Loop time of 23.3313 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.481 hours/ns, 42.861 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.249     | 23.249     | 23.249     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014908   | 0.014908   | 0.014908   |   0.0 |  0.06
Output  | 2.9255e-05 | 2.9255e-05 | 2.9255e-05 |   0.0 |  0.00
Modify  | 0.061685   | 0.061685   | 0.061685   |   0.0 |  0.26
Other   |            | 0.005435   |            |       |  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:       215918 ave      215918 max      215918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215918
Ave neighs/atom = 107.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.718024246426, Press = 0.480021449617699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8417.9183     -8417.9183     -8491.3151     -8491.3151      284.05322      284.05322      23461.328      23461.328      698.52673      698.52673    
     28000  -8411.3246     -8411.3246     -8488.5466     -8488.5466      298.85694      298.85694      23471.864      23471.864      1039.4258      1039.4258    
Loop time of 23.3617 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.489 hours/ns, 42.805 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    | 23.28      | 23.28      | 23.28      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.06
Output  | 2.1571e-05 | 2.1571e-05 | 2.1571e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.26
Other   |            | 0.00546    |            |       |  0.02

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

Total # of neighbors = 216254
Ave neighs/atom = 108.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.612291443867, Press = 2.32927281069766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8411.3246     -8411.3246     -8488.5466     -8488.5466      298.85694      298.85694      23471.864      23471.864      1039.4258      1039.4258    
     29000  -8414.9773     -8414.9773     -8489.0872     -8489.0872      286.81293      286.81293      23487.602      23487.602     -639.39798     -639.39798    
Loop time of 23.3861 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.694 ns/day, 6.496 hours/ns, 42.760 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    | 23.304     | 23.304     | 23.304     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014773   | 0.014773   | 0.014773   |   0.0 |  0.06
Output  | 2.161e-05  | 2.161e-05  | 2.161e-05  |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.26
Other   |            | 0.005441   |            |       |  0.02

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

Total # of neighbors = 216252
Ave neighs/atom = 108.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.487982282855, Press = 3.05334351976775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8414.9773     -8414.9773     -8489.0872     -8489.0872      286.81293      286.81293      23487.602      23487.602     -639.39798     -639.39798    
     30000  -8409.5966     -8409.5966     -8485.7705     -8485.7705      294.80104      294.80104      23539.845      23539.845     -3650.7967     -3650.7967    
Loop time of 23.3386 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.848 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    | 23.257     | 23.257     | 23.257     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01485    | 0.01485    | 0.01485    |   0.0 |  0.06
Output  | 3.0227e-05 | 3.0227e-05 | 3.0227e-05 |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.26
Other   |            | 0.005449   |            |       |  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:       215840 ave      215840 max      215840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215840
Ave neighs/atom = 107.92
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.477887637555, Press = 0.223216382610312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8409.5966     -8409.5966     -8485.7705     -8485.7705      294.80104      294.80104      23539.845      23539.845     -3650.7967     -3650.7967    
     31000  -8411.1397     -8411.1397     -8487.1303     -8487.1303      294.09161      294.09161      23508.973      23508.973     -1546.0376     -1546.0376    
Loop time of 23.2671 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.713 ns/day, 6.463 hours/ns, 42.979 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    | 23.185     | 23.185     | 23.185     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014923   | 0.014923   | 0.014923   |   0.0 |  0.06
Output  | 2.127e-05  | 2.127e-05  | 2.127e-05  |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.27
Other   |            | 0.005433   |            |       |  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:       214862 ave      214862 max      214862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214862
Ave neighs/atom = 107.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472738330589, Press = -1.62440640785078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8411.1397     -8411.1397     -8487.1303     -8487.1303      294.09161      294.09161      23508.973      23508.973     -1546.0376     -1546.0376    
     32000  -8412.7162     -8412.7162     -8487.794      -8487.794       290.55897      290.55897      23467.585      23467.585      1300.5549      1300.5549    
Loop time of 23.3345 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.482 hours/ns, 42.855 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    | 23.253     | 23.253     | 23.253     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014852   | 0.014852   | 0.014852   |   0.0 |  0.06
Output  | 3.0377e-05 | 3.0377e-05 | 3.0377e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.26
Other   |            | 0.005459   |            |       |  0.02

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

Total # of neighbors = 215496
Ave neighs/atom = 107.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.467433873956, Press = 0.426781610291017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8412.7162     -8412.7162     -8487.794      -8487.794       290.55897      290.55897      23467.585      23467.585      1300.5549      1300.5549    
     33000  -8411.6631     -8411.6631     -8487.2196     -8487.2196      292.41155      292.41155      23479.065      23479.065      634.73978      634.73978    
Loop time of 23.3795 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.696 ns/day, 6.494 hours/ns, 42.772 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    | 23.297     | 23.297     | 23.297     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014864   | 0.014864   | 0.014864   |   0.0 |  0.06
Output  | 2.166e-05  | 2.166e-05  | 2.166e-05  |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.26
Other   |            | 0.005441   |            |       |  0.02

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

Total # of neighbors = 216024
Ave neighs/atom = 108.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.570407586929, Press = 1.78024213606469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8411.6631     -8411.6631     -8487.2196     -8487.2196      292.41155      292.41155      23479.065      23479.065      634.73978      634.73978    
     34000  -8409.8503     -8409.8503     -8487.1436     -8487.1436      299.1328       299.1328       23505.373      23505.373     -1145.6709     -1145.6709    
Loop time of 23.3269 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.704 ns/day, 6.480 hours/ns, 42.869 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    | 23.245     | 23.245     | 23.245     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014841   | 0.014841   | 0.014841   |   0.0 |  0.06
Output  | 2.1751e-05 | 2.1751e-05 | 2.1751e-05 |   0.0 |  0.00
Modify  | 0.061672   | 0.061672   | 0.061672   |   0.0 |  0.26
Other   |            | 0.005449   |            |       |  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:       215898 ave      215898 max      215898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215898
Ave neighs/atom = 107.949
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.581499004206, Press = 0.244192247860015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8409.8503     -8409.8503     -8487.1436     -8487.1436      299.1328       299.1328       23505.373      23505.373     -1145.6709     -1145.6709    
     35000  -8412.4336     -8412.4336     -8487.7906     -8487.7906      291.63946      291.63946      23485.394      23485.394     -22.838542     -22.838542    
Loop time of 23.3179 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.885 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    | 23.236     | 23.236     | 23.236     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014859   | 0.014859   | 0.014859   |   0.0 |  0.06
Output  | 3.1148e-05 | 3.1148e-05 | 3.1148e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.26
Other   |            | 0.005429   |            |       |  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:       215610 ave      215610 max      215610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215610
Ave neighs/atom = 107.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.650755135548, Press = -0.468296210460898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8412.4336     -8412.4336     -8487.7906     -8487.7906      291.63946      291.63946      23485.394      23485.394     -22.838542     -22.838542    
     36000  -8411.2463     -8411.2463     -8486.7801     -8486.7801      292.32364      292.32364      23462.736      23462.736      1934.0489      1934.0489    
Loop time of 23.3413 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.484 hours/ns, 42.843 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    | 23.259     | 23.259     | 23.259     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014843   | 0.014843   | 0.014843   |   0.0 |  0.06
Output  | 2.146e-05  | 2.146e-05  | 2.146e-05  |   0.0 |  0.00
Modify  | 0.061628   | 0.061628   | 0.061628   |   0.0 |  0.26
Other   |            | 0.005433   |            |       |  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:       215710 ave      215710 max      215710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215710
Ave neighs/atom = 107.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.643826914413, Press = -0.155800543287569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8411.2463     -8411.2463     -8486.7801     -8486.7801      292.32364      292.32364      23462.736      23462.736      1934.0489      1934.0489    
     37000  -8411.6085     -8411.6085     -8488.7429     -8488.7429      298.5183       298.5183       23474.986      23474.986      653.4008       653.4008     
Loop time of 23.3372 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.850 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    | 23.255     | 23.255     | 23.255     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014814   | 0.014814   | 0.014814   |   0.0 |  0.06
Output  | 3.19e-05   | 3.19e-05   | 3.19e-05   |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.26
Other   |            | 0.005445   |            |       |  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:       215756 ave      215756 max      215756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215756
Ave neighs/atom = 107.878
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.618900543971, Press = 2.11226936919112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8411.6085     -8411.6085     -8488.7429     -8488.7429      298.5183       298.5183       23474.986      23474.986      653.4008       653.4008     
     38000  -8413.9842     -8413.9842     -8487.4416     -8487.4416      284.28773      284.28773      23511.74       23511.74      -2101.521      -2101.521     
Loop time of 23.3048 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.707 ns/day, 6.474 hours/ns, 42.910 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    | 23.223     | 23.223     | 23.223     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.06
Output  | 2.143e-05  | 2.143e-05  | 2.143e-05  |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.26
Other   |            | 0.005434   |            |       |  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:       215968 ave      215968 max      215968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215968
Ave neighs/atom = 107.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.574532771513, Press = 1.45202777871235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8413.9842     -8413.9842     -8487.4416     -8487.4416      284.28773      284.28773      23511.74       23511.74      -2101.521      -2101.521     
     39000  -8413.9385     -8413.9385     -8489.2811     -8489.2811      291.58372      291.58372      23514.992      23514.992     -2780.0558     -2780.0558    
Loop time of 23.3197 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.882 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    | 23.238     | 23.238     | 23.238     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.06
Output  | 2.149e-05  | 2.149e-05  | 2.149e-05  |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.26
Other   |            | 0.005431   |            |       |  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:       215308 ave      215308 max      215308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215308
Ave neighs/atom = 107.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452737642612, Press = -1.06346906471852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8413.9385     -8413.9385     -8489.2811     -8489.2811      291.58372      291.58372      23514.992      23514.992     -2780.0558     -2780.0558    
     40000  -8409.3701     -8409.3701     -8487.329      -8487.329       301.70909      301.70909      23480.381      23480.381      461.91219      461.91219    
Loop time of 23.3505 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.486 hours/ns, 42.826 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.268     | 23.268     | 23.268     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014908   | 0.014908   | 0.014908   |   0.0 |  0.06
Output  | 3.0257e-05 | 3.0257e-05 | 3.0257e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.26
Other   |            | 0.005439   |            |       |  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:       215360 ave      215360 max      215360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215360
Ave neighs/atom = 107.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.463580184485, Press = -0.898357955062772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8409.3701     -8409.3701     -8487.329      -8487.329       301.70909      301.70909      23480.381      23480.381      461.91219      461.91219    
     41000  -8412.1194     -8412.1194     -8487.6411     -8487.6411      292.27716      292.27716      23474.976      23474.976      1033.4844      1033.4844    
Loop time of 23.3676 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.697 ns/day, 6.491 hours/ns, 42.794 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    | 23.286     | 23.286     | 23.286     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014831   | 0.014831   | 0.014831   |   0.0 |  0.06
Output  | 2.134e-05  | 2.134e-05  | 2.134e-05  |   0.0 |  0.00
Modify  | 0.061676   | 0.061676   | 0.061676   |   0.0 |  0.26
Other   |            | 0.00544    |            |       |  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:       215656 ave      215656 max      215656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215656
Ave neighs/atom = 107.828
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.503452310361, Press = 0.385558617592643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8412.1194     -8412.1194     -8487.6411     -8487.6411      292.27716      292.27716      23474.976      23474.976      1033.4844      1033.4844    
     42000  -8413.3273     -8413.3273     -8489.7741     -8489.7741      295.85727      295.85727      23471.787      23471.787      685.47838      685.47838    
Loop time of 23.4018 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.692 ns/day, 6.500 hours/ns, 42.732 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    | 23.32      | 23.32      | 23.32      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014807   | 0.014807   | 0.014807   |   0.0 |  0.06
Output  | 2.7401e-05 | 2.7401e-05 | 2.7401e-05 |   0.0 |  0.00
Modify  | 0.061677   | 0.061677   | 0.061677   |   0.0 |  0.26
Other   |            | 0.005443   |            |       |  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:       216154 ave      216154 max      216154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216154
Ave neighs/atom = 108.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.56839486448, Press = 0.743358273772235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8413.3273     -8413.3273     -8489.7741     -8489.7741      295.85727      295.85727      23471.787      23471.787      685.47838      685.47838    
     43000  -8411.4239     -8411.4239     -8487.1822     -8487.1822      293.19234      293.19234      23489.441      23489.441     -180.66021     -180.66021    
Loop time of 23.3822 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.695 ns/day, 6.495 hours/ns, 42.768 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    | 23.3       | 23.3       | 23.3       |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014784   | 0.014784   | 0.014784   |   0.0 |  0.06
Output  | 2.1912e-05 | 2.1912e-05 | 2.1912e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.26
Other   |            | 0.005456   |            |       |  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:       216392 ave      216392 max      216392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216392
Ave neighs/atom = 108.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544599232202, Press = 1.06886834676805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8411.4239     -8411.4239     -8487.1822     -8487.1822      293.19234      293.19234      23489.441      23489.441     -180.66021     -180.66021    
     44000  -8413.0637     -8413.0637     -8486.7589     -8486.7589      285.20822      285.20822      23525.696      23525.696     -3008.872      -3008.872     
Loop time of 23.3266 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.704 ns/day, 6.480 hours/ns, 42.869 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    | 23.245     | 23.245     | 23.245     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014812   | 0.014812   | 0.014812   |   0.0 |  0.06
Output  | 2.164e-05  | 2.164e-05  | 2.164e-05  |   0.0 |  0.00
Modify  | 0.061691   | 0.061691   | 0.061691   |   0.0 |  0.26
Other   |            | 0.005435   |            |       |  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:       215496 ave      215496 max      215496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215496
Ave neighs/atom = 107.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.457704025079, Press = 0.864312932616581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8413.0637     -8413.0637     -8486.7589     -8486.7589      285.20822      285.20822      23525.696      23525.696     -3008.872      -3008.872     
     45000  -8412.686      -8412.686      -8489.938      -8489.938       298.97329      298.97329      23512.408      23512.408     -2401.528      -2401.528     
Loop time of 23.3109 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.475 hours/ns, 42.898 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    | 23.229     | 23.229     | 23.229     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.06
Output  | 3.0216e-05 | 3.0216e-05 | 3.0216e-05 |   0.0 |  0.00
Modify  | 0.06171    | 0.06171    | 0.06171    |   0.0 |  0.26
Other   |            | 0.005447   |            |       |  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:       215074 ave      215074 max      215074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215074
Ave neighs/atom = 107.537
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.44646433616, Press = -1.28711948472995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8412.686      -8412.686      -8489.938      -8489.938       298.97329      298.97329      23512.408      23512.408     -2401.528      -2401.528     
     46000  -8409.1858     -8409.1858     -8485.0333     -8485.0333      293.53771      293.53771      23468.537      23468.537      1943.3854      1943.3854    
Loop time of 23.3813 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.695 ns/day, 6.495 hours/ns, 42.769 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    | 23.299     | 23.299     | 23.299     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014873   | 0.014873   | 0.014873   |   0.0 |  0.06
Output  | 2.1491e-05 | 2.1491e-05 | 2.1491e-05 |   0.0 |  0.00
Modify  | 0.061592   | 0.061592   | 0.061592   |   0.0 |  0.26
Other   |            | 0.00543    |            |       |  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:       215812 ave      215812 max      215812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215812
Ave neighs/atom = 107.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.464965297116, Press = -0.906191559590635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8409.1858     -8409.1858     -8485.0333     -8485.0333      293.53771      293.53771      23468.537      23468.537      1943.3854      1943.3854    
     47000  -8411.8023     -8411.8023     -8488.7606     -8488.7606      297.83629      297.83629      23469.23       23469.23       841.42121      841.42121    
Loop time of 23.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.884 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    | 23.237     | 23.237     | 23.237     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014849   | 0.014849   | 0.014849   |   0.0 |  0.06
Output  | 2.15e-05   | 2.15e-05   | 2.15e-05   |   0.0 |  0.00
Modify  | 0.0616     | 0.0616     | 0.0616     |   0.0 |  0.26
Other   |            | 0.005444   |            |       |  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:       215664 ave      215664 max      215664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215664
Ave neighs/atom = 107.832
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.489689437887, Press = 0.875111771239625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8411.8023     -8411.8023     -8488.7606     -8488.7606      297.83629      297.83629      23469.23       23469.23       841.42121      841.42121    
     48000  -8413.3766     -8413.3766     -8488.1615     -8488.1615      289.42516      289.42516      23481.509      23481.509      253.36825      253.36825    
Loop time of 23.3987 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.693 ns/day, 6.500 hours/ns, 42.738 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    | 23.317     | 23.317     | 23.317     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.06
Output  | 3.0236e-05 | 3.0236e-05 | 3.0236e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.26
Other   |            | 0.005448   |            |       |  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:       216172 ave      216172 max      216172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216172
Ave neighs/atom = 108.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.548653030857, Press = 0.444094224991337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8413.3766     -8413.3766     -8488.1615     -8488.1615      289.42516      289.42516      23481.509      23481.509      253.36825      253.36825    
     49000  -8410.0451     -8410.0451     -8486.651      -8486.651       296.47266      296.47266      23489.309      23489.309      19.782916      19.782916    
Loop time of 23.3699 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.697 ns/day, 6.492 hours/ns, 42.790 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    | 23.288     | 23.288     | 23.288     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.06
Output  | 2.1661e-05 | 2.1661e-05 | 2.1661e-05 |   0.0 |  0.00
Modify  | 0.061674   | 0.061674   | 0.061674   |   0.0 |  0.26
Other   |            | 0.005425   |            |       |  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:       216072 ave      216072 max      216072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216072
Ave neighs/atom = 108.036
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.549398856164, Press = 0.64724908087531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8410.0451     -8410.0451     -8486.651      -8486.651       296.47266      296.47266      23489.309      23489.309      19.782916      19.782916    
     50000  -8413.5752     -8413.5752     -8490.1769     -8490.1769      296.45653      296.45653      23486.13       23486.13      -722.40171     -722.40171    
Loop time of 23.3163 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.477 hours/ns, 42.888 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.234     | 23.234     | 23.234     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014876   | 0.014876   | 0.014876   |   0.0 |  0.06
Output  | 3.1098e-05 | 3.1098e-05 | 3.1098e-05 |   0.0 |  0.00
Modify  | 0.061737   | 0.061737   | 0.061737   |   0.0 |  0.26
Other   |            | 0.005452   |            |       |  0.02

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

Total # of neighbors = 215816
Ave neighs/atom = 107.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.59102102998, Press = 0.472227378894344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8413.5752     -8413.5752     -8490.1769     -8490.1769      296.45653      296.45653      23486.13       23486.13      -722.40171     -722.40171    
     51000  -8411.2696     -8411.2696     -8487.4837     -8487.4837      294.9564       294.9564       23502.425      23502.425     -1161.8238     -1161.8238    
Loop time of 23.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.697 ns/day, 6.492 hours/ns, 42.786 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    | 23.29      | 23.29      | 23.29      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014813   | 0.014813   | 0.014813   |   0.0 |  0.06
Output  | 2.142e-05  | 2.142e-05  | 2.142e-05  |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.26
Other   |            | 0.005437   |            |       |  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:       216084 ave      216084 max      216084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216084
Ave neighs/atom = 108.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 = 293.590673193487, Press = 0.539111762228427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8411.2696     -8411.2696     -8487.4837     -8487.4837      294.9564       294.9564       23502.425      23502.425     -1161.8238     -1161.8238    
     52000  -8414.2077     -8414.2077     -8489.0422     -8489.0422      289.6174       289.6174       23494.598      23494.598     -1213.6558     -1213.6558    
Loop time of 23.3413 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.484 hours/ns, 42.842 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    | 23.259     | 23.259     | 23.259     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014907   | 0.014907   | 0.014907   |   0.0 |  0.06
Output  | 2.157e-05  | 2.157e-05  | 2.157e-05  |   0.0 |  0.00
Modify  | 0.061656   | 0.061656   | 0.061656   |   0.0 |  0.26
Other   |            | 0.005445   |            |       |  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:       215600 ave      215600 max      215600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215600
Ave neighs/atom = 107.8
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.612200290071, Press = -0.949339000752612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8414.2077     -8414.2077     -8489.0422     -8489.0422      289.6174       289.6174       23494.598      23494.598     -1213.6558     -1213.6558    
     53000  -8409.4095     -8409.4095     -8483.1599     -8483.1599      285.42154      285.42154      23471.799      23471.799      2175.168       2175.168     
Loop time of 23.3539 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.487 hours/ns, 42.819 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    | 23.272     | 23.272     | 23.272     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.06
Output  | 3.0367e-05 | 3.0367e-05 | 3.0367e-05 |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.26
Other   |            | 0.005454   |            |       |  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:       215850 ave      215850 max      215850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215850
Ave neighs/atom = 107.925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.621052511277, Press = -0.800662318376134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8409.4095     -8409.4095     -8483.1599     -8483.1599      285.42154      285.42154      23471.799      23471.799      2175.168       2175.168     
     54000  -8411.7257     -8411.7257     -8487.4048     -8487.4048      292.88576      292.88576      23442.042      23442.042      3512.8573      3512.8573    
Loop time of 23.3037 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.708 ns/day, 6.473 hours/ns, 42.912 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    | 23.222     | 23.222     | 23.222     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014858   | 0.014858   | 0.014858   |   0.0 |  0.06
Output  | 2.132e-05  | 2.132e-05  | 2.132e-05  |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.26
Other   |            | 0.005414   |            |       |  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:       215626 ave      215626 max      215626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215626
Ave neighs/atom = 107.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.625036342748, Press = 1.2156177737952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8411.7257     -8411.7257     -8487.4048     -8487.4048      292.88576      292.88576      23442.042      23442.042      3512.8573      3512.8573    
     55000  -8416.5154     -8416.5154     -8489.9939     -8489.9939      284.36935      284.36935      23491.44       23491.44      -956.7781      -956.7781     
Loop time of 23.3657 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.490 hours/ns, 42.798 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    | 23.284     | 23.284     | 23.284     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01495    | 0.01495    | 0.01495    |   0.0 |  0.06
Output  | 2.8504e-05 | 2.8504e-05 | 2.8504e-05 |   0.0 |  0.00
Modify  | 0.061741   | 0.061741   | 0.061741   |   0.0 |  0.26
Other   |            | 0.005481   |            |       |  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:       216350 ave      216350 max      216350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216350
Ave neighs/atom = 108.175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.595420222771, Press = 1.63947278888055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8416.5154     -8416.5154     -8489.9939     -8489.9939      284.36935      284.36935      23491.44       23491.44      -956.7781      -956.7781     
     56000  -8411.9784     -8411.9784     -8486.8243     -8486.8243      289.66134      289.66134      23507.476      23507.476     -1429.1883     -1429.1883    
Loop time of 23.3353 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.482 hours/ns, 42.853 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    | 23.253     | 23.253     | 23.253     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.06
Output  | 2.1259e-05 | 2.1259e-05 | 2.1259e-05 |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.26
Other   |            | 0.005435   |            |       |  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:       216064 ave      216064 max      216064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216064
Ave neighs/atom = 108.032
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.561580476178, Press = -0.0936926899832973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8411.9784     -8411.9784     -8486.8243     -8486.8243      289.66134      289.66134      23507.476      23507.476     -1429.1883     -1429.1883    
     57000  -8409.0164     -8409.0164     -8486.3446     -8486.3446      299.26813      299.26813      23493.513      23493.513     -128.70191     -128.70191    
Loop time of 23.3153 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.706 ns/day, 6.476 hours/ns, 42.890 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    | 23.233     | 23.233     | 23.233     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014821   | 0.014821   | 0.014821   |   0.0 |  0.06
Output  | 2.1721e-05 | 2.1721e-05 | 2.1721e-05 |   0.0 |  0.00
Modify  | 0.061681   | 0.061681   | 0.061681   |   0.0 |  0.26
Other   |            | 0.00542    |            |       |  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:       215648 ave      215648 max      215648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215648
Ave neighs/atom = 107.824
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.523785170012, Press = -0.702864373206109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8409.0164     -8409.0164     -8486.3446     -8486.3446      299.26813      299.26813      23493.513      23493.513     -128.70191     -128.70191    
     58000  -8412.2631     -8412.2631     -8486.7898     -8486.7898      288.42609      288.42609      23457.814      23457.814      2460.0908      2460.0908    
Loop time of 23.3209 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.478 hours/ns, 42.880 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    | 23.239     | 23.239     | 23.239     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014803   | 0.014803   | 0.014803   |   0.0 |  0.06
Output  | 3.3793e-05 | 3.3793e-05 | 3.3793e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.26
Other   |            | 0.005454   |            |       |  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:       215674 ave      215674 max      215674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215674
Ave neighs/atom = 107.837
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.542549870976, Press = -0.153827167447788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8412.2631     -8412.2631     -8486.7898     -8486.7898      288.42609      288.42609      23457.814      23457.814      2460.0908      2460.0908    
     59000  -8413.0743     -8413.0743     -8487.9751     -8487.9751      289.87413      289.87413      23448.355      23448.355      2841.7143      2841.7143    
Loop time of 23.3597 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.489 hours/ns, 42.809 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    | 23.277     | 23.277     | 23.277     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.06
Output  | 2.1481e-05 | 2.1481e-05 | 2.1481e-05 |   0.0 |  0.00
Modify  | 0.061728   | 0.061728   | 0.061728   |   0.0 |  0.26
Other   |            | 0.005455   |            |       |  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:       216344 ave      216344 max      216344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216344
Ave neighs/atom = 108.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.535477370825, Press = 1.33679672257311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8413.0743     -8413.0743     -8487.9751     -8487.9751      289.87413      289.87413      23448.355      23448.355      2841.7143      2841.7143    
     60000  -8409.3241     -8409.3241     -8485.9759     -8485.9759      296.65042      296.65042      23513.072      23513.072     -1468.5387     -1468.5387    
Loop time of 23.3384 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.848 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    | 23.256     | 23.256     | 23.256     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.06
Output  | 2.7982e-05 | 2.7982e-05 | 2.7982e-05 |   0.0 |  0.00
Modify  | 0.061748   | 0.061748   | 0.061748   |   0.0 |  0.26
Other   |            | 0.005446   |            |       |  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:       216442 ave      216442 max      216442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216442
Ave neighs/atom = 108.221
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509426667067, Press = 1.79649226796705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8409.3241     -8409.3241     -8485.9759     -8485.9759      296.65042      296.65042      23513.072      23513.072     -1468.5387     -1468.5387    
     61000  -8413.2498     -8413.2498     -8487.9652     -8487.9652      289.15651      289.15651      23509.514      23509.514     -1995.7313     -1995.7313    
Loop time of 23.3366 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.482 hours/ns, 42.851 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    | 23.255     | 23.255     | 23.255     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01483    | 0.01483    | 0.01483    |   0.0 |  0.06
Output  | 2.1821e-05 | 2.1821e-05 | 2.1821e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.26
Other   |            | 0.005436   |            |       |  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:       215442 ave      215442 max      215442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215442
Ave neighs/atom = 107.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.527186576932, Press = -0.00140913455953452
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8413.2498     -8413.2498     -8487.9652     -8487.9652      289.15651      289.15651      23509.514      23509.514     -1995.7313     -1995.7313    
     62000  -8415.3033     -8415.3033     -8489.2752     -8489.2752      286.27886      286.27886      23488.318      23488.318     -765.89686     -765.89686    
Loop time of 23.3353 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.703 ns/day, 6.482 hours/ns, 42.854 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 23.253     | 23.253     | 23.253     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014896   | 0.014896   | 0.014896   |   0.0 |  0.06
Output  | 2.149e-05  | 2.149e-05  | 2.149e-05  |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.26
Other   |            | 0.005444   |            |       |  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:       215504 ave      215504 max      215504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215504
Ave neighs/atom = 107.752
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.530004743766, Press = -0.216458572173351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8415.3033     -8415.3033     -8489.2752     -8489.2752      286.27886      286.27886      23488.318      23488.318     -765.89686     -765.89686    
     63000  -8411.8328     -8411.8328     -8487.7773     -8487.7773      293.91304      293.91304      23471.699      23471.699      1141.0064      1141.0064    
Loop time of 23.3494 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.700 ns/day, 6.486 hours/ns, 42.828 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    | 23.267     | 23.267     | 23.267     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014831   | 0.014831   | 0.014831   |   0.0 |  0.06
Output  | 3.0958e-05 | 3.0958e-05 | 3.0958e-05 |   0.0 |  0.00
Modify  | 0.061673   | 0.061673   | 0.061673   |   0.0 |  0.26
Other   |            | 0.005427   |            |       |  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:       215970 ave      215970 max      215970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215970
Ave neighs/atom = 107.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470328640577, Press = 0.17065900669758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8411.8328     -8411.8328     -8487.7773     -8487.7773      293.91304      293.91304      23471.699      23471.699      1141.0064      1141.0064    
     64000  -8415.7489     -8415.7489     -8488.169      -8488.169       280.2735       280.2735       23471.374      23471.374      802.75532      802.75532    
Loop time of 23.3386 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.483 hours/ns, 42.847 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    | 23.257     | 23.257     | 23.257     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.06
Output  | 2.1481e-05 | 2.1481e-05 | 2.1481e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.26
Other   |            | 0.005424   |            |       |  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:       215866 ave      215866 max      215866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215866
Ave neighs/atom = 107.933
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.449211133062, Press = 0.49833253997101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8415.7489     -8415.7489     -8488.169      -8488.169       280.2735       280.2735       23471.374      23471.374      802.75532      802.75532    
     65000  -8411.9613     -8411.9613     -8488.1919     -8488.1919      295.02057      295.02057      23494.624      23494.624     -757.00441     -757.00441    
Loop time of 23.3187 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.705 ns/day, 6.477 hours/ns, 42.884 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    | 23.237     | 23.237     | 23.237     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014891   | 0.014891   | 0.014891   |   0.0 |  0.06
Output  | 2.169e-05  | 2.169e-05  | 2.169e-05  |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.26
Other   |            | 0.005431   |            |       |  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:       216102 ave      216102 max      216102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216102
Ave neighs/atom = 108.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 = 293.403974741711, Press = 0.257142640460523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8411.9613     -8411.9613     -8488.1919     -8488.1919      295.02057      295.02057      23494.624      23494.624     -757.00441     -757.00441    
     66000  -8413.7112     -8413.7112     -8488.0635     -8488.0635      287.75083      287.75083      23480.496      23480.496      352.18638      352.18638    
Loop time of 23.3357 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.702 ns/day, 6.482 hours/ns, 42.853 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    | 23.254     | 23.254     | 23.254     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014879   | 0.014879   | 0.014879   |   0.0 |  0.06
Output  | 3.1589e-05 | 3.1589e-05 | 3.1589e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.26
Other   |            | 0.005462   |            |       |  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:       215584 ave      215584 max      215584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215584
Ave neighs/atom = 107.792
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.387338615147, Press = -0.127959743118851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8413.7112     -8413.7112     -8488.0635     -8488.0635      287.75083      287.75083      23480.496      23480.496      352.18638      352.18638    
     67000  -8412.4993     -8412.4993     -8487.0405     -8487.0405      288.48206      288.48206      23471.805      23471.805      1022.8346      1022.8346    
Loop time of 23.359 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.699 ns/day, 6.489 hours/ns, 42.810 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    | 23.277     | 23.277     | 23.277     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.06
Output  | 2.165e-05  | 2.165e-05  | 2.165e-05  |   0.0 |  0.00
Modify  | 0.061732   | 0.061732   | 0.061732   |   0.0 |  0.26
Other   |            | 0.005417   |            |       |  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:       216116 ave      216116 max      216116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216116
Ave neighs/atom = 108.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 = 293.385251404695, Press = -0.393481518101161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8412.4993     -8412.4993     -8487.0405     -8487.0405      288.48206      288.48206      23471.805      23471.805      1022.8346      1022.8346    
     68000  -8413.433      -8413.433      -8488.2743     -8488.2743      289.64357      289.64357      23464.674      23464.674      1536.9059      1536.9059    
Loop time of 23.3849 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.695 ns/day, 6.496 hours/ns, 42.763 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    | 23.303     | 23.303     | 23.303     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01483    | 0.01483    | 0.01483    |   0.0 |  0.06
Output  | 3.0858e-05 | 3.0858e-05 | 3.0858e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.26
Other   |            | 0.005473   |            |       |  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:       215924 ave      215924 max      215924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 215924
Ave neighs/atom = 107.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.336310572436, Press = 0.422620643135607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8413.433      -8413.433      -8488.2743     -8488.2743      289.64357      289.64357      23464.674      23464.674      1536.9059      1536.9059    
     69000  -8413.3232     -8413.3232     -8486.5599     -8486.5599      283.43382      283.43382      23481.001      23481.001      577.36164      577.36164    
Loop time of 23.3657 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.698 ns/day, 6.490 hours/ns, 42.798 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    | 23.284     | 23.284     | 23.284     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.06
Output  | 2.13e-05   | 2.13e-05   | 2.13e-05   |   0.0 |  0.00
Modify  | 0.061709   | 0.061709   | 0.061709   |   0.0 |  0.26
Other   |            | 0.005444   |            |       |  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:       216132 ave      216132 max      216132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216132
Ave neighs/atom = 108.066
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.341887513359, Press = 0.876868454696556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8413.3232     -8413.3232     -8486.5599     -8486.5599      283.43382      283.43382      23481.001      23481.001      577.36164      577.36164    
     70000  -8408.7954     -8408.7954     -8485.039      -8485.039       295.07081      295.07081      23533.615      23533.615     -2847.9336     -2847.9336    
Loop time of 23.3444 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.701 ns/day, 6.485 hours/ns, 42.837 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    | 23.262     | 23.262     | 23.262     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014899   | 0.014899   | 0.014899   |   0.0 |  0.06
Output  | 2.157e-05  | 2.157e-05  | 2.157e-05  |   0.0 |  0.00
Modify  | 0.061733   | 0.061733   | 0.061733   |   0.0 |  0.26
Other   |            | 0.005433   |            |       |  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:       215892 ave      215892 max      215892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0