# 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.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.502431 28.502431 28.502431)
  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.502431 28.502431 28.502431)
  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_MahataMukhopadhyayAsleZaeem_2022_AlFe__MO_304347095149_001
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 23155.0486762528    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*${_u_distance})
variable      V0_metal equal 23155.0486762528/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23155.0486762528*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23155.0486762528 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_304347095149_001#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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8510.0982     -8510.0982     -8580.6777     -8580.6777      273.15         273.15         23155.049      23155.049      3255.7541      3255.7541    
      1000  -8437.3034     -8437.3034     -8506.6508     -8506.6508      268.38164      268.38164      23342.958      23342.958      1237.9583      1237.9583    
Loop time of 36.6869 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.355 ns/day, 10.191 hours/ns, 27.258 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    | 36.606     | 36.606     | 36.606     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015326   | 0.015326   | 0.015326   |   0.0 |  0.04
Output  | 0.00011905 | 0.00011905 | 0.00011905 |   0.0 |  0.00
Modify  | 0.060151   | 0.060151   | 0.060151   |   0.0 |  0.16
Other   |            | 0.00557    |            |       |  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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 2.053 ns/day, 11.692 hours/ns, 23.757 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    | 42.012     | 42.012     | 42.012     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015085   | 0.015085   | 0.015085   |   0.0 |  0.04
Output  | 6.924e-05  | 6.924e-05  | 6.924e-05  |   0.0 |  0.00
Modify  | 0.05958    | 0.05958    | 0.05958    |   0.0 |  0.14
Other   |            | 0.005382   |            |       |  0.01

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:       132196 ave      132196 max      132196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132196
Ave neighs/atom = 66.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8436.5883     -8436.5883     -8505.3359     -8505.3359      266.06045      266.06045      23393.662      23393.662     -2128.3128     -2128.3128    
      3000  -8438.4943     -8438.4943     -8511.8004     -8511.8004      283.70238      283.70238      23374.376      23374.376     -1517.8513     -1517.8513    
Loop time of 42.2418 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.045 ns/day, 11.734 hours/ns, 23.673 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    | 42.162     | 42.162     | 42.162     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.04
Output  | 5.0254e-05 | 5.0254e-05 | 5.0254e-05 |   0.0 |  0.00
Modify  | 0.059571   | 0.059571   | 0.059571   |   0.0 |  0.14
Other   |            | 0.005245   |            |       |  0.01

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:       131526 ave      131526 max      131526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131526
Ave neighs/atom = 65.763
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8438.4943     -8438.4943     -8511.8004     -8511.8004      283.70238      283.70238      23374.376      23374.376     -1517.8513     -1517.8513    
      4000  -8436.162      -8436.162      -8504.2277     -8504.2277      263.42163      263.42163      23358.183      23358.183      527.8421       527.8421     
Loop time of 42.2951 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.043 ns/day, 11.749 hours/ns, 23.643 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    | 42.215     | 42.215     | 42.215     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.04
Output  | 6.4832e-05 | 6.4832e-05 | 6.4832e-05 |   0.0 |  0.00
Modify  | 0.059586   | 0.059586   | 0.059586   |   0.0 |  0.14
Other   |            | 0.005278   |            |       |  0.01

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:       131012 ave      131012 max      131012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131012
Ave neighs/atom = 65.506
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8436.162      -8436.162      -8504.2277     -8504.2277      263.42163      263.42163      23358.183      23358.183      527.8421       527.8421     
      5000  -8438.5473     -8438.5473     -8511.2398     -8511.2398      281.32731      281.32731      23350.889      23350.889      228.73182      228.73182    
Loop time of 42.3544 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.040 ns/day, 11.765 hours/ns, 23.610 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    | 42.274     | 42.274     | 42.274     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015166   | 0.015166   | 0.015166   |   0.0 |  0.04
Output  | 3.1168e-05 | 3.1168e-05 | 3.1168e-05 |   0.0 |  0.00
Modify  | 0.059899   | 0.059899   | 0.059899   |   0.0 |  0.14
Other   |            | 0.005296   |            |       |  0.01

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:       131940 ave      131940 max      131940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131940
Ave neighs/atom = 65.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 269.271776713428, Press = -138.283180797713
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8438.5473     -8438.5473     -8511.2398     -8511.2398      281.32731      281.32731      23350.889      23350.889      228.73182      228.73182    
      6000  -8436.469      -8436.469      -8505.4441     -8505.4441      266.94084      266.94084      23348.839      23348.839      1197.0405      1197.0405    
Loop time of 42.3568 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.040 ns/day, 11.766 hours/ns, 23.609 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    | 42.274     | 42.274     | 42.274     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.04
Output  | 4.763e-05  | 4.763e-05  | 4.763e-05  |   0.0 |  0.00
Modify  | 0.062113   | 0.062113   | 0.062113   |   0.0 |  0.15
Other   |            | 0.005365   |            |       |  0.01

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:       131256 ave      131256 max      131256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131256
Ave neighs/atom = 65.628
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.350885416916, Press = -5.22620867208062
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8436.469      -8436.469      -8505.4441     -8505.4441      266.94084      266.94084      23348.839      23348.839      1197.0405      1197.0405    
      7000  -8439.0813     -8439.0813     -8509.9578     -8509.9578      274.29949      274.29949      23365.684      23365.684     -740.20028     -740.20028    
Loop time of 42.5994 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.833 hours/ns, 23.475 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    | 42.517     | 42.517     | 42.517     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.04
Output  | 5.321e-05  | 5.321e-05  | 5.321e-05  |   0.0 |  0.00
Modify  | 0.061938   | 0.061938   | 0.061938   |   0.0 |  0.15
Other   |            | 0.005417   |            |       |  0.01

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:       131768 ave      131768 max      131768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131768
Ave neighs/atom = 65.884
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 271.644354288695, Press = 21.5734497625026
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8439.0813     -8439.0813     -8509.9578     -8509.9578      274.29949      274.29949      23365.684      23365.684     -740.20028     -740.20028    
      8000  -8437.3202     -8437.3202     -8506.3341     -8506.3341      267.09088      267.09088      23392.01       23392.01      -1976.7846     -1976.7846    
Loop time of 42.3887 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.038 ns/day, 11.775 hours/ns, 23.591 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    | 42.306     | 42.306     | 42.306     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015049   | 0.015049   | 0.015049   |   0.0 |  0.04
Output  | 3.8021e-05 | 3.8021e-05 | 3.8021e-05 |   0.0 |  0.00
Modify  | 0.06203    | 0.06203    | 0.06203    |   0.0 |  0.15
Other   |            | 0.005435   |            |       |  0.01

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:       131460 ave      131460 max      131460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131460
Ave neighs/atom = 65.73
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.644096617496, Press = -3.56960641139722
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8437.3202     -8437.3202     -8506.3341     -8506.3341      267.09088      267.09088      23392.01       23392.01      -1976.7846     -1976.7846    
      9000  -8442.4533     -8442.4533     -8510.5132     -8510.5132      263.39888      263.39888      23383.56       23383.56      -2093.6633     -2093.6633    
Loop time of 42.2745 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.044 ns/day, 11.743 hours/ns, 23.655 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    | 42.192     | 42.192     | 42.192     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01497    | 0.01497    | 0.01497    |   0.0 |  0.04
Output  | 3.0187e-05 | 3.0187e-05 | 3.0187e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.15
Other   |            | 0.00539    |            |       |  0.01

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:       131272 ave      131272 max      131272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131272
Ave neighs/atom = 65.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.149659732109, Press = -18.8421264298654
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8442.4533     -8442.4533     -8510.5132     -8510.5132      263.39888      263.39888      23383.56       23383.56      -2093.6633     -2093.6633    
     10000  -8436.5663     -8436.5663     -8508.3359     -8508.3359      277.75579      277.75579      23339.862      23339.862      1500.1147      1500.1147    
Loop time of 42.5457 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.031 ns/day, 11.818 hours/ns, 23.504 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    | 42.463     | 42.463     | 42.463     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015089   | 0.015089   | 0.015089   |   0.0 |  0.04
Output  | 4.3542e-05 | 4.3542e-05 | 4.3542e-05 |   0.0 |  0.00
Modify  | 0.06198    | 0.06198    | 0.06198    |   0.0 |  0.15
Other   |            | 0.005322   |            |       |  0.01

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:       131090 ave      131090 max      131090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131090
Ave neighs/atom = 65.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.013772372305, Press = -14.6423170167739
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8436.5663     -8436.5663     -8508.3359     -8508.3359      277.75579      277.75579      23339.862      23339.862      1500.1147      1500.1147    
     11000  -8439.3579     -8439.3579     -8510.9434     -8510.9434      277.04317      277.04317      23331.949      23331.949      1568.6848      1568.6848    
Loop time of 42.4297 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.036 ns/day, 11.786 hours/ns, 23.568 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    | 42.348     | 42.348     | 42.348     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.04
Output  | 3.9013e-05 | 3.9013e-05 | 3.9013e-05 |   0.0 |  0.00
Modify  | 0.061813   | 0.061813   | 0.061813   |   0.0 |  0.15
Other   |            | 0.005351   |            |       |  0.01

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:       131644 ave      131644 max      131644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131644
Ave neighs/atom = 65.822
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.252783606189, Press = 0.144329100383718
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8439.3579     -8439.3579     -8510.9434     -8510.9434      277.04317      277.04317      23331.949      23331.949      1568.6848      1568.6848    
     12000  -8436.5844     -8436.5844     -8507.9985     -8507.9985      276.37984      276.37984      23355.058      23355.058      428.03768      428.03768    
Loop time of 42.3634 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.039 ns/day, 11.768 hours/ns, 23.605 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    | 42.281     | 42.281     | 42.281     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.04
Output  | 3.1439e-05 | 3.1439e-05 | 3.1439e-05 |   0.0 |  0.00
Modify  | 0.061789   | 0.061789   | 0.061789   |   0.0 |  0.15
Other   |            | 0.005375   |            |       |  0.01

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:       131558 ave      131558 max      131558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131558
Ave neighs/atom = 65.779
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.051621572717, Press = 2.45029033253723
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8436.5844     -8436.5844     -8507.9985     -8507.9985      276.37984      276.37984      23355.058      23355.058      428.03768      428.03768    
     13000  -8439.233      -8439.233      -8507.507      -8507.507       264.22743      264.22743      23353.17       23353.17       407.78289      407.78289    
Loop time of 42.4916 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.033 ns/day, 11.803 hours/ns, 23.534 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    | 42.409     | 42.409     | 42.409     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015065   | 0.015065   | 0.015065   |   0.0 |  0.04
Output  | 4.6788e-05 | 4.6788e-05 | 4.6788e-05 |   0.0 |  0.00
Modify  | 0.06204    | 0.06204    | 0.06204    |   0.0 |  0.15
Other   |            | 0.00538    |            |       |  0.01

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:       131328 ave      131328 max      131328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131328
Ave neighs/atom = 65.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.080755672962, Press = 2.97322292865982
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8439.233      -8439.233      -8507.507      -8507.507       264.22743      264.22743      23353.17       23353.17       407.78289      407.78289    
     14000  -8436.7707     -8436.7707     -8506.966      -8506.966       271.66324      271.66324      23379.446      23379.446     -1216.3247     -1216.3247    
Loop time of 42.3067 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.042 ns/day, 11.752 hours/ns, 23.637 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    | 42.224     | 42.224     | 42.224     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015031   | 0.015031   | 0.015031   |   0.0 |  0.04
Output  | 4.5957e-05 | 4.5957e-05 | 4.5957e-05 |   0.0 |  0.00
Modify  | 0.061871   | 0.061871   | 0.061871   |   0.0 |  0.15
Other   |            | 0.005305   |            |       |  0.01

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:       131514 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.462621375591, Press = -0.939298274547677
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8436.7707     -8436.7707     -8506.966      -8506.966       271.66324      271.66324      23379.446      23379.446     -1216.3247     -1216.3247    
     15000  -8435.5913     -8435.5913     -8506.5323     -8506.5323      274.54896      274.54896      23388.923      23388.923     -1747.4973     -1747.4973    
Loop time of 42.3306 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.041 ns/day, 11.759 hours/ns, 23.624 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    | 42.248     | 42.248     | 42.248     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015034   | 0.015034   | 0.015034   |   0.0 |  0.04
Output  | 3.1539e-05 | 3.1539e-05 | 3.1539e-05 |   0.0 |  0.00
Modify  | 0.061876   | 0.061876   | 0.061876   |   0.0 |  0.15
Other   |            | 0.005396   |            |       |  0.01

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:       131534 ave      131534 max      131534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131534
Ave neighs/atom = 65.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 = 272.604935584994, Press = -8.8457572431719
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8435.5913     -8435.5913     -8506.5323     -8506.5323      274.54896      274.54896      23388.923      23388.923     -1747.4973     -1747.4973    
     16000  -8439.3334     -8439.3334     -8509.2147     -8509.2147      270.44767      270.44767      23330.23       23330.23       1918.8257      1918.8257    
Loop time of 42.3468 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.040 ns/day, 11.763 hours/ns, 23.615 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    | 42.264     | 42.264     | 42.264     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015083   | 0.015083   | 0.015083   |   0.0 |  0.04
Output  | 4.6608e-05 | 4.6608e-05 | 4.6608e-05 |   0.0 |  0.00
Modify  | 0.062023   | 0.062023   | 0.062023   |   0.0 |  0.15
Other   |            | 0.005363   |            |       |  0.01

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:       131432 ave      131432 max      131432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131432
Ave neighs/atom = 65.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.808570026277, Press = -5.19340511998533
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8439.3334     -8439.3334     -8509.2147     -8509.2147      270.44767      270.44767      23330.23       23330.23       1918.8257      1918.8257    
     17000  -8437.832      -8437.832      -8507.8658     -8507.8658      271.03821      271.03821      23327.151      23327.151      2278.514       2278.514     
Loop time of 42.5077 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.033 ns/day, 11.808 hours/ns, 23.525 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    | 42.425     | 42.425     | 42.425     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015057   | 0.015057   | 0.015057   |   0.0 |  0.04
Output  | 4.4614e-05 | 4.4614e-05 | 4.4614e-05 |   0.0 |  0.00
Modify  | 0.061962   | 0.061962   | 0.061962   |   0.0 |  0.15
Other   |            | 0.005376   |            |       |  0.01

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:       131606 ave      131606 max      131606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131606
Ave neighs/atom = 65.803
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.89221106757, Press = 1.16971331239761
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8437.832      -8437.832      -8507.8658     -8507.8658      271.03821      271.03821      23327.151      23327.151      2278.514       2278.514     
     18000  -8436.9219     -8436.9219     -8505.1557     -8505.1557      264.07166      264.07166      23357.17       23357.17       596.21589      596.21589    
Loop time of 42.5709 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.030 ns/day, 11.825 hours/ns, 23.490 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    | 42.488     | 42.488     | 42.488     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014978   | 0.014978   | 0.014978   |   0.0 |  0.04
Output  | 3.9885e-05 | 3.9885e-05 | 3.9885e-05 |   0.0 |  0.00
Modify  | 0.061993   | 0.061993   | 0.061993   |   0.0 |  0.15
Other   |            | 0.005383   |            |       |  0.01

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:       131828 ave      131828 max      131828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131828
Ave neighs/atom = 65.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.924049733116, Press = 1.43921797129316
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8436.9219     -8436.9219     -8505.1557     -8505.1557      264.07166      264.07166      23357.17       23357.17       596.21589      596.21589    
     19000  -8437.353      -8437.353      -8509.1146     -8509.1146      277.72492      277.72492      23368.944      23368.944     -696.05543     -696.05543    
Loop time of 42.4154 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.037 ns/day, 11.782 hours/ns, 23.576 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    | 42.333     | 42.333     | 42.333     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.04
Output  | 3.1699e-05 | 3.1699e-05 | 3.1699e-05 |   0.0 |  0.00
Modify  | 0.061964   | 0.061964   | 0.061964   |   0.0 |  0.15
Other   |            | 0.00539    |            |       |  0.01

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:       131724 ave      131724 max      131724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131724
Ave neighs/atom = 65.862
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.924971544368, Press = -0.12147579231232
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8437.353      -8437.353      -8509.1146     -8509.1146      277.72492      277.72492      23368.944      23368.944     -696.05543     -696.05543    
     20000  -8439.0123     -8439.0123     -8508.6956     -8508.6956      269.6817       269.6817       23362.556      23362.556     -311.63573     -311.63573    
Loop time of 42.5924 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.029 ns/day, 11.831 hours/ns, 23.478 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    | 42.51      | 42.51      | 42.51      |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.04
Output  | 4.811e-05  | 4.811e-05  | 4.811e-05  |   0.0 |  0.00
Modify  | 0.061922   | 0.061922   | 0.061922   |   0.0 |  0.15
Other   |            | 0.005386   |            |       |  0.01

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:       131314 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.946994235163, Press = -1.28004456347142
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8439.0123     -8439.0123     -8508.6956     -8508.6956      269.6817       269.6817       23362.556      23362.556     -311.63573     -311.63573    
     21000  -8438.053      -8438.053      -8508.4055     -8508.4055      272.27123      272.27123      23354.415      23354.415      326.8747       326.8747     
Loop time of 42.5842 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.029 ns/day, 11.829 hours/ns, 23.483 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    | 42.502     | 42.502     | 42.502     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015149   | 0.015149   | 0.015149   |   0.0 |  0.04
Output  | 4.2059e-05 | 4.2059e-05 | 4.2059e-05 |   0.0 |  0.00
Modify  | 0.062012   | 0.062012   | 0.062012   |   0.0 |  0.15
Other   |            | 0.005389   |            |       |  0.01

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:       131312 ave      131312 max      131312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131312
Ave neighs/atom = 65.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.781970743632, Press = -1.05928200466057
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8438.053      -8438.053      -8508.4055     -8508.4055      272.27123      272.27123      23354.415      23354.415      326.8747       326.8747     
     22000  -8436.8213     -8436.8213     -8506.5082     -8506.5082      269.69562      269.69562      23349.469      23349.469      950.476        950.476      
Loop time of 42.5783 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.029 ns/day, 11.827 hours/ns, 23.486 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    | 42.496     | 42.496     | 42.496     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015158   | 0.015158   | 0.015158   |   0.0 |  0.04
Output  | 3.0137e-05 | 3.0137e-05 | 3.0137e-05 |   0.0 |  0.00
Modify  | 0.061985   | 0.061985   | 0.061985   |   0.0 |  0.15
Other   |            | 0.005406   |            |       |  0.01

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:       131314 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.821052940168, Press = -0.980879620769798
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8436.8213     -8436.8213     -8506.5082     -8506.5082      269.69562      269.69562      23349.469      23349.469      950.476        950.476      
     23000  -8437.2475     -8437.2475     -8508.2092     -8508.2092      274.62927      274.62927      23351.469      23351.469      636.56156      636.56156    
Loop time of 42.4831 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.034 ns/day, 11.801 hours/ns, 23.539 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    | 42.4       | 42.4       | 42.4       |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015176   | 0.015176   | 0.015176   |   0.0 |  0.04
Output  | 3.9704e-05 | 3.9704e-05 | 3.9704e-05 |   0.0 |  0.00
Modify  | 0.062088   | 0.062088   | 0.062088   |   0.0 |  0.15
Other   |            | 0.005425   |            |       |  0.01

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:       131508 ave      131508 max      131508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131508
Ave neighs/atom = 65.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.840895932478, Press = 0.37621095547504
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8437.2475     -8437.2475     -8508.2092     -8508.2092      274.62927      274.62927      23351.469      23351.469      636.56156      636.56156    
     24000  -8436.8597     -8436.8597     -8508.5301     -8508.5301      277.37166      277.37166      23370.967      23370.967     -697.17647     -697.17647    
Loop time of 42.3068 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.042 ns/day, 11.752 hours/ns, 23.637 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    | 42.224     | 42.224     | 42.224     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015426   | 0.015426   | 0.015426   |   0.0 |  0.04
Output  | 6.2327e-05 | 6.2327e-05 | 6.2327e-05 |   0.0 |  0.00
Modify  | 0.06235    | 0.06235    | 0.06235    |   0.0 |  0.15
Other   |            | 0.005441   |            |       |  0.01

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:       131556 ave      131556 max      131556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131556
Ave neighs/atom = 65.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.810134837411, Press = 1.51746520513419
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8436.8597     -8436.8597     -8508.5301     -8508.5301      277.37166      277.37166      23370.967      23370.967     -697.17647     -697.17647    
     25000  -8438.756      -8438.756      -8507.9318     -8507.9318      267.71725      267.71725      23387.234      23387.234     -1875.5798     -1875.5798    
Loop time of 42.3418 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.041 ns/day, 11.762 hours/ns, 23.617 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    | 42.259     | 42.259     | 42.259     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015344   | 0.015344   | 0.015344   |   0.0 |  0.04
Output  | 4.2159e-05 | 4.2159e-05 | 4.2159e-05 |   0.0 |  0.00
Modify  | 0.062154   | 0.062154   | 0.062154   |   0.0 |  0.15
Other   |            | 0.005355   |            |       |  0.01

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:       131246 ave      131246 max      131246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131246
Ave neighs/atom = 65.623
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.825852644167, Press = -1.03738447275391
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8438.756      -8438.756      -8507.9318     -8507.9318      267.71725      267.71725      23387.234      23387.234     -1875.5798     -1875.5798    
     26000  -8438.497      -8438.497      -8506.2932     -8506.2932      262.37855      262.37855      23378.334      23378.334     -1045.8005     -1045.8005    
Loop time of 42.4317 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.036 ns/day, 11.787 hours/ns, 23.567 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    | 42.349     | 42.349     | 42.349     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015329   | 0.015329   | 0.015329   |   0.0 |  0.04
Output  | 5.5104e-05 | 5.5104e-05 | 5.5104e-05 |   0.0 |  0.00
Modify  | 0.062372   | 0.062372   | 0.062372   |   0.0 |  0.15
Other   |            | 0.005367   |            |       |  0.01

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:       131178 ave      131178 max      131178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131178
Ave neighs/atom = 65.589
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.691107779617, Press = -3.94483400791764
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8438.497      -8438.497      -8506.2932     -8506.2932      262.37855      262.37855      23378.334      23378.334     -1045.8005     -1045.8005    
     27000  -8437.622      -8437.622      -8507.3785     -8507.3785      269.96467      269.96467      23325.685      23325.685      2595.9254      2595.9254    
Loop time of 42.5118 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.032 ns/day, 11.809 hours/ns, 23.523 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    | 42.429     | 42.429     | 42.429     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015129   | 0.015129   | 0.015129   |   0.0 |  0.04
Output  | 4.4423e-05 | 4.4423e-05 | 4.4423e-05 |   0.0 |  0.00
Modify  | 0.061994   | 0.061994   | 0.061994   |   0.0 |  0.15
Other   |            | 0.005266   |            |       |  0.01

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:       131348 ave      131348 max      131348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131348
Ave neighs/atom = 65.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.667600234354, Press = -4.51106678384922
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8437.622      -8437.622      -8507.3785     -8507.3785      269.96467      269.96467      23325.685      23325.685      2595.9254      2595.9254    
     28000  -8434.1959     -8434.1959     -8505.8623     -8505.8623      277.35641      277.35641      23309.004      23309.004      3975.4747      3975.4747    
Loop time of 42.6309 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.027 ns/day, 11.842 hours/ns, 23.457 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    | 42.548     | 42.548     | 42.548     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015126   | 0.015126   | 0.015126   |   0.0 |  0.04
Output  | 3.2131e-05 | 3.2131e-05 | 3.2131e-05 |   0.0 |  0.00
Modify  | 0.062143   | 0.062143   | 0.062143   |   0.0 |  0.15
Other   |            | 0.005255   |            |       |  0.01

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:       131702 ave      131702 max      131702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131702
Ave neighs/atom = 65.851
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.672439673881, Press = 0.101702741810913
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8434.1959     -8434.1959     -8505.8623     -8505.8623      277.35641      277.35641      23309.004      23309.004      3975.4747      3975.4747    
     29000  -8437.6398     -8437.6398     -8508.1907     -8508.1907      273.03916      273.03916      23351.871      23351.871      542.95345      542.95345    
Loop time of 42.6137 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.837 hours/ns, 23.467 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    | 42.531     | 42.531     | 42.531     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015195   | 0.015195   | 0.015195   |   0.0 |  0.04
Output  | 5.4021e-05 | 5.4021e-05 | 5.4021e-05 |   0.0 |  0.00
Modify  | 0.062065   | 0.062065   | 0.062065   |   0.0 |  0.15
Other   |            | 0.005276   |            |       |  0.01

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:       132042 ave      132042 max      132042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132042
Ave neighs/atom = 66.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.720705349959, Press = 1.48019831192127
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8437.6398     -8437.6398     -8508.1907     -8508.1907      273.03916      273.03916      23351.871      23351.871      542.95345      542.95345    
     30000  -8434.5556     -8434.5556     -8505.8549     -8505.8549      275.93591      275.93591      23379.895      23379.895     -1033.081      -1033.081     
Loop time of 42.4044 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.038 ns/day, 11.779 hours/ns, 23.582 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    | 42.322     | 42.322     | 42.322     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015155   | 0.015155   | 0.015155   |   0.0 |  0.04
Output  | 2.9145e-05 | 2.9145e-05 | 2.9145e-05 |   0.0 |  0.00
Modify  | 0.061944   | 0.061944   | 0.061944   |   0.0 |  0.15
Other   |            | 0.005235   |            |       |  0.01

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:       131572 ave      131572 max      131572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131572
Ave neighs/atom = 65.786
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.829208824399, Press = 0.949723517361865
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8434.5556     -8434.5556     -8505.8549     -8505.8549      275.93591      275.93591      23379.895      23379.895     -1033.081      -1033.081     
     31000  -8438.3945     -8438.3945     -8507.1699     -8507.1699      266.16794      266.16794      23379.161      23379.161     -1275.1825     -1275.1825    
Loop time of 42.4079 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.037 ns/day, 11.780 hours/ns, 23.580 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    | 42.325     | 42.325     | 42.325     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015184   | 0.015184   | 0.015184   |   0.0 |  0.04
Output  | 4.1538e-05 | 4.1538e-05 | 4.1538e-05 |   0.0 |  0.00
Modify  | 0.061998   | 0.061998   | 0.061998   |   0.0 |  0.15
Other   |            | 0.005249   |            |       |  0.01

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:       131416 ave      131416 max      131416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131416
Ave neighs/atom = 65.708
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.901128875693, Press = -1.34817138968238
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8438.3945     -8438.3945     -8507.1699     -8507.1699      266.16794      266.16794      23379.161      23379.161     -1275.1825     -1275.1825    
     32000  -8439.2058     -8439.2058     -8508.3439     -8508.3439      267.57162      267.57162      23352.168      23352.168      526.84739      526.84739    
Loop time of 42.5133 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.032 ns/day, 11.809 hours/ns, 23.522 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    | 42.431     | 42.431     | 42.431     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015134   | 0.015134   | 0.015134   |   0.0 |  0.04
Output  | 2.9595e-05 | 2.9595e-05 | 2.9595e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.15
Other   |            | 0.005262   |            |       |  0.01

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:       131454 ave      131454 max      131454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131454
Ave neighs/atom = 65.727
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.952645753747, Press = -2.3091397099001
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8439.2058     -8439.2058     -8508.3439     -8508.3439      267.57162      267.57162      23352.168      23352.168      526.84739      526.84739    
     33000  -8436.9924     -8436.9924     -8507.2467     -8507.2467      271.89122      271.89122      23297.098      23297.098      4481.1198      4481.1198    
Loop time of 42.5516 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.030 ns/day, 11.820 hours/ns, 23.501 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    | 42.469     | 42.469     | 42.469     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015157   | 0.015157   | 0.015157   |   0.0 |  0.04
Output  | 4.3792e-05 | 4.3792e-05 | 4.3792e-05 |   0.0 |  0.00
Modify  | 0.061874   | 0.061874   | 0.061874   |   0.0 |  0.15
Other   |            | 0.005263   |            |       |  0.01

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:       131512 ave      131512 max      131512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131512
Ave neighs/atom = 65.756
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.890762504043, Press = -0.754003703797564
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8436.9924     -8436.9924     -8507.2467     -8507.2467      271.89122      271.89122      23297.098      23297.098      4481.1198      4481.1198    
     34000  -8440.6489     -8440.6489     -8508.1084     -8508.1084      261.07548      261.07548      23332.063      23332.063      1756.2794      1756.2794    
Loop time of 42.5439 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.031 ns/day, 11.818 hours/ns, 23.505 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    | 42.462     | 42.462     | 42.462     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015117   | 0.015117   | 0.015117   |   0.0 |  0.04
Output  | 4.8772e-05 | 4.8772e-05 | 4.8772e-05 |   0.0 |  0.00
Modify  | 0.061886   | 0.061886   | 0.061886   |   0.0 |  0.15
Other   |            | 0.00529    |            |       |  0.01

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:       132046 ave      132046 max      132046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 132046
Ave neighs/atom = 66.023
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.861157091651, Press = 1.89525726259572
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8440.6489     -8440.6489     -8508.1084     -8508.1084      261.07548      261.07548      23332.063      23332.063      1756.2794      1756.2794    
     35000  -8436.7909     -8436.7909     -8507.2997     -8507.2997      272.87613      272.87613      23370.15       23370.15      -575.89692     -575.89692    
Loop time of 42.6016 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.834 hours/ns, 23.473 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    | 42.519     | 42.519     | 42.519     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015137   | 0.015137   | 0.015137   |   0.0 |  0.04
Output  | 3.1289e-05 | 3.1289e-05 | 3.1289e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.15
Other   |            | 0.005273   |            |       |  0.01

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:       131672 ave      131672 max      131672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131672
Ave neighs/atom = 65.836
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.81664617014, Press = 1.13126712464344
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8436.7909     -8436.7909     -8507.2997     -8507.2997      272.87613      272.87613      23370.15       23370.15      -575.89692     -575.89692    
     36000  -8440.9042     -8440.9042     -8507.4133     -8507.4133      257.39717      257.39717      23383.013      23383.013     -1684.1242     -1684.1242    
Loop time of 42.5505 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.031 ns/day, 11.820 hours/ns, 23.501 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    | 42.468     | 42.468     | 42.468     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015053   | 0.015053   | 0.015053   |   0.0 |  0.04
Output  | 4.9183e-05 | 4.9183e-05 | 4.9183e-05 |   0.0 |  0.00
Modify  | 0.061988   | 0.061988   | 0.061988   |   0.0 |  0.15
Other   |            | 0.005291   |            |       |  0.01

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:       131390 ave      131390 max      131390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131390
Ave neighs/atom = 65.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 = 272.786753128278, Press = 0.0186675302398129
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8440.9042     -8440.9042     -8507.4133     -8507.4133      257.39717      257.39717      23383.013      23383.013     -1684.1242     -1684.1242    
     37000  -8436.7029     -8436.7029     -8507.7607     -8507.7607      275.00087      275.00087      23382.241      23382.241     -1466.9931     -1466.9931    
Loop time of 42.5713 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.030 ns/day, 11.825 hours/ns, 23.490 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    | 42.489     | 42.489     | 42.489     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015118   | 0.015118   | 0.015118   |   0.0 |  0.04
Output  | 4.0065e-05 | 4.0065e-05 | 4.0065e-05 |   0.0 |  0.00
Modify  | 0.06201    | 0.06201    | 0.06201    |   0.0 |  0.15
Other   |            | 0.005235   |            |       |  0.01

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:       131398 ave      131398 max      131398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131398
Ave neighs/atom = 65.699
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.750960888307, Press = -1.86084221452282
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8436.7029     -8436.7029     -8507.7607     -8507.7607      275.00087      275.00087      23382.241      23382.241     -1466.9931     -1466.9931    
     38000  -8438.6678     -8438.6678     -8509.2314     -8509.2314      273.08856      273.08856      23338.624      23338.624      1279.4825      1279.4825    
Loop time of 42.6785 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.024 ns/day, 11.855 hours/ns, 23.431 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    | 42.596     | 42.596     | 42.596     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015142   | 0.015142   | 0.015142   |   0.0 |  0.04
Output  | 0.00011199 | 0.00011199 | 0.00011199 |   0.0 |  0.00
Modify  | 0.06213    | 0.06213    | 0.06213    |   0.0 |  0.15
Other   |            | 0.005253   |            |       |  0.01

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:       131240 ave      131240 max      131240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131240
Ave neighs/atom = 65.62
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.743793774428, Press = -1.78926285893842
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8438.6678     -8438.6678     -8509.2314     -8509.2314      273.08856      273.08856      23338.624      23338.624      1279.4825      1279.4825    
     39000  -8437.2142     -8437.2142     -8506.9516     -8506.9516      269.89089      269.89089      23340.295      23340.295      1546.6208      1546.6208    
Loop time of 42.5556 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.030 ns/day, 11.821 hours/ns, 23.499 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 42.473     | 42.473     | 42.473     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01505    | 0.01505    | 0.01505    |   0.0 |  0.04
Output  | 2.6379e-05 | 2.6379e-05 | 2.6379e-05 |   0.0 |  0.00
Modify  | 0.061991   | 0.061991   | 0.061991   |   0.0 |  0.15
Other   |            | 0.00524    |            |       |  0.01

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:       131542 ave      131542 max      131542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131542
Ave neighs/atom = 65.771
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.831405342643, Press = -0.459104531344313
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8437.2142     -8437.2142     -8506.9516     -8506.9516      269.89089      269.89089      23340.295      23340.295      1546.6208      1546.6208    
     40000  -8437.2242     -8437.2242     -8508.656      -8508.656       276.44828      276.44828      23356.493      23356.493      190.25321      190.25321    
Loop time of 42.6249 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.027 ns/day, 11.840 hours/ns, 23.460 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    | 42.542     | 42.542     | 42.542     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015072   | 0.015072   | 0.015072   |   0.0 |  0.04
Output  | 4.2991e-05 | 4.2991e-05 | 4.2991e-05 |   0.0 |  0.00
Modify  | 0.062166   | 0.062166   | 0.062166   |   0.0 |  0.15
Other   |            | 0.00525    |            |       |  0.01

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:       131660 ave      131660 max      131660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131660
Ave neighs/atom = 65.83
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.822161298238, Press = 0.390028797003229
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8437.2242     -8437.2242     -8508.656      -8508.656       276.44828      276.44828      23356.493      23356.493      190.25321      190.25321    
     41000  -8437.4819     -8437.4819     -8508.4805     -8508.4805      274.77195      274.77195      23363.52       23363.52      -234.29119     -234.29119    
Loop time of 42.6439 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.026 ns/day, 11.846 hours/ns, 23.450 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    | 42.561     | 42.561     | 42.561     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01519    | 0.01519    | 0.01519    |   0.0 |  0.04
Output  | 3.9915e-05 | 3.9915e-05 | 3.9915e-05 |   0.0 |  0.00
Modify  | 0.062039   | 0.062039   | 0.062039   |   0.0 |  0.15
Other   |            | 0.005267   |            |       |  0.01

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:       131428 ave      131428 max      131428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131428
Ave neighs/atom = 65.714
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.828364862958, Press = -0.134175804237386
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8437.4819     -8437.4819     -8508.4805     -8508.4805      274.77195      274.77195      23363.52       23363.52      -234.29119     -234.29119    
     42000  -8435.8479     -8435.8479     -8506.045      -8506.045       271.66998      271.66998      23380.224      23380.224     -1118.5908     -1118.5908    
Loop time of 42.5919 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.029 ns/day, 11.831 hours/ns, 23.479 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    | 42.509     | 42.509     | 42.509     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015167   | 0.015167   | 0.015167   |   0.0 |  0.04
Output  | 3.209e-05  | 3.209e-05  | 3.209e-05  |   0.0 |  0.00
Modify  | 0.062122   | 0.062122   | 0.062122   |   0.0 |  0.15
Other   |            | 0.005275   |            |       |  0.01

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:       131448 ave      131448 max      131448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131448
Ave neighs/atom = 65.724
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.814884656204, Press = -0.362375590831578
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8435.8479     -8435.8479     -8506.045      -8506.045       271.66998      271.66998      23380.224      23380.224     -1118.5908     -1118.5908    
     43000  -8438.2717     -8438.2717     -8508.0633     -8508.0633      270.1008       270.1008       23376.686      23376.686     -1270.1601     -1270.1601    
Loop time of 42.4655 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.035 ns/day, 11.796 hours/ns, 23.549 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    | 42.383     | 42.383     | 42.383     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01526    | 0.01526    | 0.01526    |   0.0 |  0.04
Output  | 4.26e-05   | 4.26e-05   | 4.26e-05   |   0.0 |  0.00
Modify  | 0.062126   | 0.062126   | 0.062126   |   0.0 |  0.15
Other   |            | 0.005271   |            |       |  0.01

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:       131526 ave      131526 max      131526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131526
Ave neighs/atom = 65.763
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.842524834332, Press = -2.02792311132964
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8438.2717     -8438.2717     -8508.0633     -8508.0633      270.1008       270.1008       23376.686      23376.686     -1270.1601     -1270.1601    
     44000  -8433.8543     -8433.8543     -8505.3787     -8505.3787      276.80695      276.80695      23348.156      23348.156      1340.8619      1340.8619    
Loop time of 42.6016 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.834 hours/ns, 23.473 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    | 42.519     | 42.519     | 42.519     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015137   | 0.015137   | 0.015137   |   0.0 |  0.04
Output  | 4.3432e-05 | 4.3432e-05 | 4.3432e-05 |   0.0 |  0.00
Modify  | 0.062219   | 0.062219   | 0.062219   |   0.0 |  0.15
Other   |            | 0.005255   |            |       |  0.01

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:       131406 ave      131406 max      131406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131406
Ave neighs/atom = 65.703
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.905547235295, Press = -1.26335112770068
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8433.8543     -8433.8543     -8505.3787     -8505.3787      276.80695      276.80695      23348.156      23348.156      1340.8619      1340.8619    
     45000  -8438.0359     -8438.0359     -8509.4206     -8509.4206      276.26605      276.26605      23318.018      23318.018      2763.9538      2763.9538    
Loop time of 42.5936 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.832 hours/ns, 23.478 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    | 42.511     | 42.511     | 42.511     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015139   | 0.015139   | 0.015139   |   0.0 |  0.04
Output  | 3.4355e-05 | 3.4355e-05 | 3.4355e-05 |   0.0 |  0.00
Modify  | 0.062125   | 0.062125   | 0.062125   |   0.0 |  0.15
Other   |            | 0.005264   |            |       |  0.01

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:       131650 ave      131650 max      131650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131650
Ave neighs/atom = 65.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.973670233614, Press = 0.390422438620099
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8438.0359     -8438.0359     -8509.4206     -8509.4206      276.26605      276.26605      23318.018      23318.018      2763.9538      2763.9538    
     46000  -8435.4909     -8435.4909     -8506.7423     -8506.7423      275.75061      275.75061      23361.759      23361.759      49.224759      49.224759    
Loop time of 42.5876 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.029 ns/day, 11.830 hours/ns, 23.481 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    | 42.505     | 42.505     | 42.505     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015125   | 0.015125   | 0.015125   |   0.0 |  0.04
Output  | 2.68e-05   | 2.68e-05   | 2.68e-05   |   0.0 |  0.00
Modify  | 0.062092   | 0.062092   | 0.062092   |   0.0 |  0.15
Other   |            | 0.005254   |            |       |  0.01

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:       131610 ave      131610 max      131610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131610
Ave neighs/atom = 65.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 = 273.000473514194, Press = 0.949750394147737
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8435.4909     -8435.4909     -8506.7423     -8506.7423      275.75061      275.75061      23361.759      23361.759      49.224759      49.224759    
     47000  -8441.9982     -8441.9982     -8509.8026     -8509.8026      262.40987      262.40987      23367.89       23367.89      -953.86879     -953.86879    
Loop time of 42.6386 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.026 ns/day, 11.844 hours/ns, 23.453 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 42.556     | 42.556     | 42.556     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01512    | 0.01512    | 0.01512    |   0.0 |  0.04
Output  | 4.2961e-05 | 4.2961e-05 | 4.2961e-05 |   0.0 |  0.00
Modify  | 0.062217   | 0.062217   | 0.062217   |   0.0 |  0.15
Other   |            | 0.005283   |            |       |  0.01

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:       131672 ave      131672 max      131672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131672
Ave neighs/atom = 65.836
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.949877595353, Press = -0.0561943522768386
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8441.9982     -8441.9982     -8509.8026     -8509.8026      262.40987      262.40987      23367.89       23367.89      -953.86879     -953.86879    
     48000  -8436.8899     -8436.8899     -8507.1382     -8507.1382      271.86811      271.86811      23365.375      23365.375     -250.77521     -250.77521    
Loop time of 42.6842 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.024 ns/day, 11.857 hours/ns, 23.428 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    | 42.602     | 42.602     | 42.602     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015064   | 0.015064   | 0.015064   |   0.0 |  0.04
Output  | 4.4002e-05 | 4.4002e-05 | 4.4002e-05 |   0.0 |  0.00
Modify  | 0.06205    | 0.06205    | 0.06205    |   0.0 |  0.15
Other   |            | 0.005257   |            |       |  0.01

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:       131326 ave      131326 max      131326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131326
Ave neighs/atom = 65.663
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.935447824346, Press = -0.628231510697948
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8436.8899     -8436.8899     -8507.1382     -8507.1382      271.86811      271.86811      23365.375      23365.375     -250.77521     -250.77521    
     49000  -8437.9993     -8437.9993     -8507.2829     -8507.2829      268.13471      268.13471      23351.431      23351.431      619.5845       619.5845     
Loop time of 42.7331 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.870 hours/ns, 23.401 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    | 42.651     | 42.651     | 42.651     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015163   | 0.015163   | 0.015163   |   0.0 |  0.04
Output  | 2.6018e-05 | 2.6018e-05 | 2.6018e-05 |   0.0 |  0.00
Modify  | 0.062037   | 0.062037   | 0.062037   |   0.0 |  0.15
Other   |            | 0.005248   |            |       |  0.01

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:       131514 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.884221910192, Press = -0.52936080508117
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8437.9993     -8437.9993     -8507.2829     -8507.2829      268.13471      268.13471      23351.431      23351.431      619.5845       619.5845     
     50000  -8436.4737     -8436.4737     -8508.0972     -8508.0972      277.19016      277.19016      23335.219      23335.219      1742.8525      1742.8525    
Loop time of 42.4872 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.034 ns/day, 11.802 hours/ns, 23.537 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    | 42.405     | 42.405     | 42.405     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015244   | 0.015244   | 0.015244   |   0.0 |  0.04
Output  | 5.3851e-05 | 5.3851e-05 | 5.3851e-05 |   0.0 |  0.00
Modify  | 0.062076   | 0.062076   | 0.062076   |   0.0 |  0.15
Other   |            | 0.005278   |            |       |  0.01

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:       131678 ave      131678 max      131678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131678
Ave neighs/atom = 65.839
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.94702201896, Press = -0.00562920730132674
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8436.4737     -8436.4737     -8508.0972     -8508.0972      277.19016      277.19016      23335.219      23335.219      1742.8525      1742.8525    
     51000  -8435.4565     -8435.4565     -8506.6804     -8506.6804      275.64396      275.64396      23352.632      23352.632      714.71523      714.71523    
Loop time of 42.8582 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.905 hours/ns, 23.333 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    | 42.775     | 42.775     | 42.775     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015218   | 0.015218   | 0.015218   |   0.0 |  0.04
Output  | 3.9133e-05 | 3.9133e-05 | 3.9133e-05 |   0.0 |  0.00
Modify  | 0.062252   | 0.062252   | 0.062252   |   0.0 |  0.15
Other   |            | 0.005226   |            |       |  0.01

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:       131760 ave      131760 max      131760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131760
Ave neighs/atom = 65.88
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.965721916151, Press = 1.97101129481771
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8435.4565     -8435.4565     -8506.6804     -8506.6804      275.64396      275.64396      23352.632      23352.632      714.71523      714.71523    
     52000  -8438.5776     -8438.5776     -8508.4895     -8508.4895      270.5662       270.5662       23390.682      23390.682     -2249.4401     -2249.4401    
Loop time of 42.6751 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.025 ns/day, 11.854 hours/ns, 23.433 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    | 42.592     | 42.592     | 42.592     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0152     | 0.0152     | 0.0152     |   0.0 |  0.04
Output  | 3.6549e-05 | 3.6549e-05 | 3.6549e-05 |   0.0 |  0.00
Modify  | 0.062332   | 0.062332   | 0.062332   |   0.0 |  0.15
Other   |            | 0.005236   |            |       |  0.01

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:       131822 ave      131822 max      131822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131822
Ave neighs/atom = 65.911
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.021557543476, Press = 0.461046166525119
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8438.5776     -8438.5776     -8508.4895     -8508.4895      270.5662       270.5662       23390.682      23390.682     -2249.4401     -2249.4401    
     53000  -8434.6623     -8434.6623     -8506.5663     -8506.5663      278.27568      278.27568      23383.169      23383.169     -1371.9779     -1371.9779    
Loop time of 42.5964 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.028 ns/day, 11.832 hours/ns, 23.476 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    | 42.514     | 42.514     | 42.514     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015187   | 0.015187   | 0.015187   |   0.0 |  0.04
Output  | 2.5107e-05 | 2.5107e-05 | 2.5107e-05 |   0.0 |  0.00
Modify  | 0.062249   | 0.062249   | 0.062249   |   0.0 |  0.15
Other   |            | 0.005234   |            |       |  0.01

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:       131314 ave      131314 max      131314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131314
Ave neighs/atom = 65.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.0275034975, Press = -0.807180604450997
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8434.6623     -8434.6623     -8506.5663     -8506.5663      278.27568      278.27568      23383.169      23383.169     -1371.9779     -1371.9779    
     54000  -8436.2475     -8436.2475     -8507.2415     -8507.2415      274.75429      274.75429      23359.252      23359.252      136.52403      136.52403    
Loop time of 42.6972 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.024 ns/day, 11.860 hours/ns, 23.421 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    | 42.614     | 42.614     | 42.614     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015182   | 0.015182   | 0.015182   |   0.0 |  0.04
Output  | 3.8402e-05 | 3.8402e-05 | 3.8402e-05 |   0.0 |  0.00
Modify  | 0.062268   | 0.062268   | 0.062268   |   0.0 |  0.15
Other   |            | 0.005255   |            |       |  0.01

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:       131520 ave      131520 max      131520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131520
Ave neighs/atom = 65.76
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.032147452892, Press = -1.19639523916763
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8436.2475     -8436.2475     -8507.2415     -8507.2415      274.75429      274.75429      23359.252      23359.252      136.52403      136.52403    
     55000  -8438.0953     -8438.0953     -8508.4728     -8508.4728      272.36828      272.36828      23328.488      23328.488      2089.6426      2089.6426    
Loop time of 42.7369 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.871 hours/ns, 23.399 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    | 42.654     | 42.654     | 42.654     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015241   | 0.015241   | 0.015241   |   0.0 |  0.04
Output  | 4.0345e-05 | 4.0345e-05 | 4.0345e-05 |   0.0 |  0.00
Modify  | 0.062345   | 0.062345   | 0.062345   |   0.0 |  0.15
Other   |            | 0.005274   |            |       |  0.01

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:       131754 ave      131754 max      131754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131754
Ave neighs/atom = 65.877
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 272.991200230635, Press = -0.366756897433495
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8438.0953     -8438.0953     -8508.4728     -8508.4728      272.36828      272.36828      23328.488      23328.488      2089.6426      2089.6426    
     56000  -8434.9288     -8434.9288     -8505.9226     -8505.9226      274.75343      274.75343      23339.525      23339.525      1739.8188      1739.8188    
Loop time of 42.8272 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.017 ns/day, 11.896 hours/ns, 23.350 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    | 42.744     | 42.744     | 42.744     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015218   | 0.015218   | 0.015218   |   0.0 |  0.04
Output  | 2.5638e-05 | 2.5638e-05 | 2.5638e-05 |   0.0 |  0.00
Modify  | 0.062162   | 0.062162   | 0.062162   |   0.0 |  0.15
Other   |            | 0.00526    |            |       |  0.01

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:       131662 ave      131662 max      131662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131662
Ave neighs/atom = 65.831
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.038105437249, Press = 0.823223048054211
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8434.9288     -8434.9288     -8505.9226     -8505.9226      274.75343      274.75343      23339.525      23339.525      1739.8188      1739.8188    
     57000  -8438.1824     -8438.1824     -8507.6783     -8507.6783      268.95611      268.95611      23382.453      23382.453     -1606.2757     -1606.2757    
Loop time of 42.9744 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.010 ns/day, 11.937 hours/ns, 23.270 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    | 42.891     | 42.891     | 42.891     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01518    | 0.01518    | 0.01518    |   0.0 |  0.04
Output  | 5.4723e-05 | 5.4723e-05 | 5.4723e-05 |   0.0 |  0.00
Modify  | 0.06259    | 0.06259    | 0.06259    |   0.0 |  0.15
Other   |            | 0.005301   |            |       |  0.01

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:       131858 ave      131858 max      131858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131858
Ave neighs/atom = 65.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.068227127553, Press = 1.58459863968598
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8438.1824     -8438.1824     -8507.6783     -8507.6783      268.95611      268.95611      23382.453      23382.453     -1606.2757     -1606.2757    
     58000  -8439.076      -8439.076      -8510.4955     -8510.4955      276.40074      276.40074      23390.162      23390.162     -2496.4891     -2496.4891    
Loop time of 42.7397 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.022 ns/day, 11.872 hours/ns, 23.397 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    | 42.657     | 42.657     | 42.657     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015224   | 0.015224   | 0.015224   |   0.0 |  0.04
Output  | 3.8542e-05 | 3.8542e-05 | 3.8542e-05 |   0.0 |  0.00
Modify  | 0.062376   | 0.062376   | 0.062376   |   0.0 |  0.15
Other   |            | 0.005264   |            |       |  0.01

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:       131432 ave      131432 max      131432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131432
Ave neighs/atom = 65.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.086810334585, Press = -0.376543376274858
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8439.076      -8439.076      -8510.4955     -8510.4955      276.40074      276.40074      23390.162      23390.162     -2496.4891     -2496.4891    
     59000  -8437.636      -8437.636      -8508.6438     -8508.6438      274.80731      274.80731      23369.18       23369.18      -772.86091     -772.86091    
Loop time of 42.7711 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.020 ns/day, 11.881 hours/ns, 23.380 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    | 42.688     | 42.688     | 42.688     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015324   | 0.015324   | 0.015324   |   0.0 |  0.04
Output  | 2.5979e-05 | 2.5979e-05 | 2.5979e-05 |   0.0 |  0.00
Modify  | 0.062361   | 0.062361   | 0.062361   |   0.0 |  0.15
Other   |            | 0.005231   |            |       |  0.01

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:       131124 ave      131124 max      131124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131124
Ave neighs/atom = 65.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.037053317233, Press = -0.844389406035095
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8437.636      -8437.636      -8508.6438     -8508.6438      274.80731      274.80731      23369.18       23369.18      -772.86091     -772.86091    
     60000  -8438.4937     -8438.4937     -8506.7887     -8506.7887      264.30887      264.30887      23350.379      23350.379      711.06955      711.06955    
Loop time of 42.9121 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.013 ns/day, 11.920 hours/ns, 23.303 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    | 42.829     | 42.829     | 42.829     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015268   | 0.015268   | 0.015268   |   0.0 |  0.04
Output  | 4.242e-05  | 4.242e-05  | 4.242e-05  |   0.0 |  0.00
Modify  | 0.062388   | 0.062388   | 0.062388   |   0.0 |  0.15
Other   |            | 0.00525    |            |       |  0.01

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:       131514 ave      131514 max      131514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131514
Ave neighs/atom = 65.757
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.039898117616, Press = -0.419062124172426
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8438.4937     -8438.4937     -8506.7887     -8506.7887      264.30887      264.30887      23350.379      23350.379      711.06955      711.06955    
     61000  -8436.5494     -8436.5494     -8506.6948     -8506.6948      271.47024      271.47024      23344.726      23344.726      1141.5171      1141.5171    
Loop time of 42.8671 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.016 ns/day, 11.908 hours/ns, 23.328 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    | 42.784     | 42.784     | 42.784     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015203   | 0.015203   | 0.015203   |   0.0 |  0.04
Output  | 3.8462e-05 | 3.8462e-05 | 3.8462e-05 |   0.0 |  0.00
Modify  | 0.062407   | 0.062407   | 0.062407   |   0.0 |  0.15
Other   |            | 0.005265   |            |       |  0.01

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:       131700 ave      131700 max      131700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131700
Ave neighs/atom = 65.85
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.03579280541, Press = 0.295720419119804
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8436.5494     -8436.5494     -8506.6948     -8506.6948      271.47024      271.47024      23344.726      23344.726      1141.5171      1141.5171    
     62000  -8436.1426     -8436.1426     -8506.9345     -8506.9345      273.97223      273.97223      23378.471      23378.471     -1133.4533     -1133.4533    
Loop time of 42.6662 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.025 ns/day, 11.852 hours/ns, 23.438 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    | 42.583     | 42.583     | 42.583     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015129   | 0.015129   | 0.015129   |   0.0 |  0.04
Output  | 4.0065e-05 | 4.0065e-05 | 4.0065e-05 |   0.0 |  0.00
Modify  | 0.062302   | 0.062302   | 0.062302   |   0.0 |  0.15
Other   |            | 0.00525    |            |       |  0.01

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:       131690 ave      131690 max      131690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131690
Ave neighs/atom = 65.845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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 = 273.035654381374, Press = 1.17980572691923
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.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8436.1426     -8436.1426     -8506.9345     -8506.9345      273.97223      273.97223      23378.471      23378.471     -1133.4533     -1133.4533    
     63000  -8438.6557     -8438.6557     -8507.6527     -8507.6527      267.02538      267.02538      23401.307      23401.307     -2908.2055     -2908.2055    
Loop time of 42.8153 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.018 ns/day, 11.893 hours/ns, 23.356 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    | 42.732     | 42.732     | 42.732     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015279   | 0.015279   | 0.015279   |   0.0 |  0.04
Output  | 2.658e-05  | 2.658e-05  | 2.658e-05  |   0.0 |  0.00
Modify  | 0.062423   | 0.062423   | 0.062423   |   0.0 |  0.15
Other   |            | 0.005239   |            |       |  0.01

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:       131470 ave      131470 max      131470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 131470
Ave neighs/atom = 65.735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
23360.4705972591

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0