# 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.8809780403971668*${_u_distance}
variable latticeconst_converted equal 2.8809780403971668*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097804039717
Lattice spacing in x,y,z = 2.880978 2.880978 2.880978
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.80978 28.80978 28.80978)
  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.80978 28.80978 28.80978)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ChoiKimSeol_2017_CrMn__MO_671124822359_002
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23912.2170404509 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_671124822359_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8119.0849     -8119.0849     -8200          -8200           313.15         313.15         23912.217      23912.217      3614.3172      3614.3172    
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11447     -939.11447    
Loop time of 163.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.527 ns/day, 45.519 hours/ns, 6.102 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 163.31     | 163.31     | 163.31     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10364    | 0.10364    | 0.10364    |   0.0 |  0.06
Output  | 0.00028566 | 0.00028566 | 0.00028566 |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  0.24
Other   |            | 0.06384    |            |       |  0.04

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

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8034.7316     -8034.7316     -8116.9191     -8116.9191      318.07431      318.07431      24192.555      24192.555     -939.11447     -939.11447    
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3756     -1582.3756    
Loop time of 144.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.199 hours/ns, 6.910 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.22     | 144.22     | 144.22     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09667    | 0.09667    | 0.09667    |   0.0 |  0.07
Output  | 0.00021764 | 0.00021764 | 0.00021764 |   0.0 |  0.00
Modify  | 0.33686    | 0.33686    | 0.33686    |   0.0 |  0.23
Other   |            | 0.05872    |            |       |  0.04

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

Total # of neighbors = 206564
Ave neighs/atom = 103.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8034.3447     -8034.3447     -8118.9608     -8118.9608      327.47303      327.47303      24196.98       24196.98      -1582.3756     -1582.3756    
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68684     -506.68684    
Loop time of 144.875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.243 hours/ns, 6.903 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.38     | 144.38     | 144.38     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095752   | 0.095752   | 0.095752   |   0.0 |  0.07
Output  | 0.00021357 | 0.00021357 | 0.00021357 |   0.0 |  0.00
Modify  | 0.33641    | 0.33641    | 0.33641    |   0.0 |  0.23
Other   |            | 0.05887    |            |       |  0.04

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

Total # of neighbors = 206666
Ave neighs/atom = 103.333
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8036.7986     -8036.7986     -8119.7713     -8119.7713      321.11318      321.11318      24178.976      24178.976     -506.68684     -506.68684    
      4000  -8033.2416     -8033.2416     -8119.0169     -8119.0169      331.95953      331.95953      24178.751      24178.751     -451.00732     -451.00732    
Loop time of 145.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.288 hours/ns, 6.895 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.54     | 144.54     | 144.54     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096615   | 0.096615   | 0.096615   |   0.0 |  0.07
Output  | 0.00025365 | 0.00025365 | 0.00025365 |   0.0 |  0.00
Modify  | 0.33644    | 0.33644    | 0.33644    |   0.0 |  0.23
Other   |            | 0.05922    |            |       |  0.04

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

Total # of neighbors = 206678
Ave neighs/atom = 103.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8033.2416     -8033.2416     -8119.0169     -8119.0169      331.95953      331.95953      24178.751      24178.751     -451.00732     -451.00732    
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24303      305.24303      24165.256      24165.256      1124.7621      1124.7621    
Loop time of 147.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 40.998 hours/ns, 6.775 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.09     | 147.09     | 147.09     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097223   | 0.097223   | 0.097223   |   0.0 |  0.07
Output  | 0.00023094 | 0.00023094 | 0.00023094 |   0.0 |  0.00
Modify  | 0.34699    | 0.34699    | 0.34699    |   0.0 |  0.24
Other   |            | 0.06066    |            |       |  0.04

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

Total # of neighbors = 206744
Ave neighs/atom = 103.372
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.786248607203, Press = 62.1634895402079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8037.8415     -8037.8415     -8116.7136     -8116.7136      305.24303      305.24303      24165.256      24165.256      1124.7621      1124.7621    
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03154      321.03154      24203.412      24203.412     -2259.4054     -2259.4054    
Loop time of 170.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.469 hours/ns, 5.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.27     | 170.27     | 170.27     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10847    | 0.10847    | 0.10847    |   0.0 |  0.06
Output  | 0.00016893 | 0.00016893 | 0.00016893 |   0.0 |  0.00
Modify  | 0.44298    | 0.44298    | 0.44298    |   0.0 |  0.26
Other   |            | 0.06649    |            |       |  0.04

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

Total # of neighbors = 207024
Ave neighs/atom = 103.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.542315191171, Press = -2.22769991829401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8034.5199     -8034.5199     -8117.4716     -8117.4716      321.03154      321.03154      24203.412      24203.412     -2259.4054     -2259.4054    
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.01512      304.01512      24184.276      24184.276     -252.31571     -252.31571    
Loop time of 153.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.611 hours/ns, 6.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.85     | 152.85     | 152.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10031    | 0.10031    | 0.10031    |   0.0 |  0.07
Output  | 0.00020874 | 0.00020874 | 0.00020874 |   0.0 |  0.00
Modify  | 0.38591    | 0.38591    | 0.38591    |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

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

Total # of neighbors = 206110
Ave neighs/atom = 103.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.244196593789, Press = -11.3932463846449
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8036.1811     -8036.1811     -8114.7359     -8114.7359      304.01512      304.01512      24184.276      24184.276     -252.31571     -252.31571    
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71402      311.71402      24156.754      24156.754      1349.8628      1349.8628    
Loop time of 169.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.153 hours/ns, 5.891 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.14     | 169.14     | 169.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10829    | 0.10829    | 0.10829    |   0.0 |  0.06
Output  | 0.00025089 | 0.00025089 | 0.00025089 |   0.0 |  0.00
Modify  | 0.43679    | 0.43679    | 0.43679    |   0.0 |  0.26
Other   |            | 0.06579    |            |       |  0.04

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

Total # of neighbors = 206482
Ave neighs/atom = 103.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.940472111766, Press = -11.1925400631458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8036.5388     -8036.5388     -8117.0829     -8117.0829      311.71402      311.71402      24156.754      24156.754      1349.8628      1349.8628    
      9000  -8034.8399     -8034.8399     -8115.7998     -8115.7998      313.323        313.323        24183.118      24183.118     -350.26498     -350.26498    
Loop time of 170.339 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.316 hours/ns, 5.871 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.72     | 169.72     | 169.72     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.06
Output  | 0.00016966 | 0.00016966 | 0.00016966 |   0.0 |  0.00
Modify  | 0.44079    | 0.44079    | 0.44079    |   0.0 |  0.26
Other   |            | 0.06611    |            |       |  0.04

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

Total # of neighbors = 207028
Ave neighs/atom = 103.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.753916878199, Press = 10.4971474289111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8034.8399     -8034.8399     -8115.7998     -8115.7998      313.323        313.323        24183.118      24183.118     -350.26498     -350.26498    
     10000  -8038.7255     -8038.7255     -8120.7641     -8120.7641      317.49779      317.49779      24205.292      24205.292     -3030.4903     -3030.4903    
Loop time of 170.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.436 hours/ns, 5.856 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.15     | 170.15     | 170.15     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1095     | 0.1095     | 0.1095     |   0.0 |  0.06
Output  | 0.00020488 | 0.00020488 | 0.00020488 |   0.0 |  0.00
Modify  | 0.44327    | 0.44327    | 0.44327    |   0.0 |  0.26
Other   |            | 0.06721    |            |       |  0.04

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

Total # of neighbors = 206486
Ave neighs/atom = 103.243
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.667502170963, Press = -13.0150021871233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8038.7255     -8038.7255     -8120.7641     -8120.7641      317.49779      317.49779      24205.292      24205.292     -3030.4903     -3030.4903    
     11000  -8034.7538     -8034.7538     -8114.2763     -8114.2763      307.76019      307.76019      24147.34       24147.34       2870.3097      2870.3097    
Loop time of 153.223 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.562 hours/ns, 6.526 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.68     | 152.68     | 152.68     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099885   | 0.099885   | 0.099885   |   0.0 |  0.07
Output  | 0.00025609 | 0.00025609 | 0.00025609 |   0.0 |  0.00
Modify  | 0.38318    | 0.38318    | 0.38318    |   0.0 |  0.25
Other   |            | 0.06099    |            |       |  0.04

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

Total # of neighbors = 206444
Ave neighs/atom = 103.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.588676958045, Press = -8.96034692869086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8034.7538     -8034.7538     -8114.2763     -8114.2763      307.76019      307.76019      24147.34       24147.34       2870.3097      2870.3097    
     12000  -8034.9583     -8034.9583     -8116.5262     -8116.5262      315.67636      315.67636      24165.225      24165.225      1281.6871      1281.6871    
Loop time of 171.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.504 ns/day, 47.662 hours/ns, 5.828 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.97     | 170.97     | 170.97     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10871    | 0.10871    | 0.10871    |   0.0 |  0.06
Output  | 0.00022563 | 0.00022563 | 0.00022563 |   0.0 |  0.00
Modify  | 0.43928    | 0.43928    | 0.43928    |   0.0 |  0.26
Other   |            | 0.06633    |            |       |  0.04

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

Total # of neighbors = 207212
Ave neighs/atom = 103.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.746935983083, Press = 6.20601755255497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8034.9583     -8034.9583     -8116.5262     -8116.5262      315.67636      315.67636      24165.225      24165.225      1281.6871      1281.6871    
     13000  -8034.6673     -8034.6673     -8115.5086     -8115.5086      312.86419      312.86419      24195.607      24195.607     -1234.1156     -1234.1156    
Loop time of 150.502 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.806 hours/ns, 6.644 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.97     | 149.97     | 149.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098297   | 0.098297   | 0.098297   |   0.0 |  0.07
Output  | 0.00016663 | 0.00016663 | 0.00016663 |   0.0 |  0.00
Modify  | 0.37272    | 0.37272    | 0.37272    |   0.0 |  0.25
Other   |            | 0.06002    |            |       |  0.04

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

Total # of neighbors = 207360
Ave neighs/atom = 103.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.213793760409, Press = -2.94474747119165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8034.6673     -8034.6673     -8115.5086     -8115.5086      312.86419      312.86419      24195.607      24195.607     -1234.1156     -1234.1156    
     14000  -8035.2882     -8035.2882     -8116.1837     -8116.1837      313.07401      313.07401      24170.837      24170.837      782.92986      782.92986    
Loop time of 144.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.242 hours/ns, 6.903 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.36     | 144.36     | 144.36     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096189   | 0.096189   | 0.096189   |   0.0 |  0.07
Output  | 0.00020242 | 0.00020242 | 0.00020242 |   0.0 |  0.00
Modify  | 0.35624    | 0.35624    | 0.35624    |   0.0 |  0.25
Other   |            | 0.05774    |            |       |  0.04

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

Total # of neighbors = 206466
Ave neighs/atom = 103.233
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.297952759889, Press = -2.60662171499433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8035.2882     -8035.2882     -8116.1837     -8116.1837      313.07401      313.07401      24170.837      24170.837      782.92986      782.92986    
     15000  -8034.9812     -8034.9812     -8113.564      -8113.564       304.12357      304.12357      24173.439      24173.439      886.07638      886.07638    
Loop time of 157.544 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.762 hours/ns, 6.347 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.98     | 156.98     | 156.98     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10223    | 0.10223    | 0.10223    |   0.0 |  0.06
Output  | 0.00017085 | 0.00017085 | 0.00017085 |   0.0 |  0.00
Modify  | 0.39618    | 0.39618    | 0.39618    |   0.0 |  0.25
Other   |            | 0.06194    |            |       |  0.04

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

Total # of neighbors = 207118
Ave neighs/atom = 103.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.368470371457, Press = -0.817933956220508
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8034.9812     -8034.9812     -8113.564      -8113.564       304.12357      304.12357      24173.439      24173.439      886.07638      886.07638    
     16000  -8034.1172     -8034.1172     -8116.0083     -8116.0083      316.92698      316.92698      24208.859      24208.859     -2336.6576     -2336.6576    
Loop time of 144.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.224 hours/ns, 6.906 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.3      | 144.3      | 144.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095468   | 0.095468   | 0.095468   |   0.0 |  0.07
Output  | 0.00016739 | 0.00016739 | 0.00016739 |   0.0 |  0.00
Modify  | 0.35588    | 0.35588    | 0.35588    |   0.0 |  0.25
Other   |            | 0.05771    |            |       |  0.04

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

Total # of neighbors = 206690
Ave neighs/atom = 103.345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.39488040261, Press = -2.43420354488976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8034.1172     -8034.1172     -8116.0083     -8116.0083      316.92698      316.92698      24208.859      24208.859     -2336.6576     -2336.6576    
     17000  -8037.0913     -8037.0913     -8115.5971     -8115.5971      303.8254       303.8254       24165.327      24165.327      1139.5622      1139.5622    
Loop time of 144.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.177 hours/ns, 6.914 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.13     | 144.13     | 144.13     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09556    | 0.09556    | 0.09556    |   0.0 |  0.07
Output  | 0.00020176 | 0.00020176 | 0.00020176 |   0.0 |  0.00
Modify  | 0.3554     | 0.3554     | 0.3554     |   0.0 |  0.25
Other   |            | 0.05758    |            |       |  0.04

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

Total # of neighbors = 206156
Ave neighs/atom = 103.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.525006246847, Press = -7.34588424439539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8037.0913     -8037.0913     -8115.5971     -8115.5971      303.8254       303.8254       24165.327      24165.327      1139.5622      1139.5622    
     18000  -8033.032      -8033.032      -8117.5715     -8117.5715      327.17657      327.17657      24145.85       24145.85       2352.7869      2352.7869    
Loop time of 146.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.828 hours/ns, 6.804 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 146.46     | 146.46     | 146.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096955   | 0.096955   | 0.096955   |   0.0 |  0.07
Output  | 0.00021191 | 0.00021191 | 0.00021191 |   0.0 |  0.00
Modify  | 0.3632     | 0.3632     | 0.3632     |   0.0 |  0.25
Other   |            | 0.0581     |            |       |  0.04

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

Total # of neighbors = 206822
Ave neighs/atom = 103.411
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.541249155574, Press = 1.78939051370105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8033.032      -8033.032      -8117.5715     -8117.5715      327.17657      327.17657      24145.85       24145.85       2352.7869      2352.7869    
     19000  -8036.8255     -8036.8255     -8116.429      -8116.429       308.07365      308.07365      24203.242      24203.242     -1974.3338     -1974.3338    
Loop time of 156.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.552 ns/day, 43.479 hours/ns, 6.389 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.97     | 155.97     | 155.97     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10176    | 0.10176    | 0.10176    |   0.0 |  0.07
Output  | 0.00021594 | 0.00021594 | 0.00021594 |   0.0 |  0.00
Modify  | 0.39463    | 0.39463    | 0.39463    |   0.0 |  0.25
Other   |            | 0.06107    |            |       |  0.04

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

Total # of neighbors = 207446
Ave neighs/atom = 103.723
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.590929507425, Press = 0.781464765433964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8036.8255     -8036.8255     -8116.429      -8116.429       308.07365      308.07365      24203.242      24203.242     -1974.3338     -1974.3338    
     20000  -8035.4586     -8035.4586     -8117.048      -8117.048       315.7596       315.7596       24182.167      24182.167     -522.6841      -522.6841     
Loop time of 169.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.156 hours/ns, 5.891 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.15     | 169.15     | 169.15     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.06
Output  | 0.00021918 | 0.00021918 | 0.00021918 |   0.0 |  0.00
Modify  | 0.44118    | 0.44118    | 0.44118    |   0.0 |  0.26
Other   |            | 0.06544    |            |       |  0.04

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

Total # of neighbors = 206278
Ave neighs/atom = 103.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.429144463623, Press = -3.25043557437431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8035.4586     -8035.4586     -8117.048      -8117.048       315.7596       315.7596       24182.167      24182.167     -522.6841      -522.6841     
     21000  -8036.5155     -8036.5155     -8117.3426     -8117.3426      312.80908      312.80908      24163.332      24163.332      843.48498      843.48498    
Loop time of 170.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.407 hours/ns, 5.859 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.05     | 170.05     | 170.05     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10788    | 0.10788    | 0.10788    |   0.0 |  0.06
Output  | 0.00016845 | 0.00016845 | 0.00016845 |   0.0 |  0.00
Modify  | 0.44091    | 0.44091    | 0.44091    |   0.0 |  0.26
Other   |            | 0.06551    |            |       |  0.04

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

Total # of neighbors = 206618
Ave neighs/atom = 103.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.491522937467, Press = -1.74334549148338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8036.5155     -8036.5155     -8117.3426     -8117.3426      312.80908      312.80908      24163.332      24163.332      843.48498      843.48498    
     22000  -8033.7083     -8033.7083     -8116.9176     -8116.9176      322.02835      322.02835      24195.224      24195.224     -1384.6048     -1384.6048    
Loop time of 163.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.529 ns/day, 45.358 hours/ns, 6.124 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.7      | 162.7      | 162.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10501    | 0.10501    | 0.10501    |   0.0 |  0.06
Output  | 0.00020348 | 0.00020348 | 0.00020348 |   0.0 |  0.00
Modify  | 0.4176     | 0.4176     | 0.4176     |   0.0 |  0.26
Other   |            | 0.06379    |            |       |  0.04

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

Total # of neighbors = 206844
Ave neighs/atom = 103.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.52016696841, Press = -0.295579725218645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8033.7083     -8033.7083     -8116.9176     -8116.9176      322.02835      322.02835      24195.224      24195.224     -1384.6048     -1384.6048    
     23000  -8036.4223     -8036.4223     -8117.5271     -8117.5271      313.88389      313.88389      24181.681      24181.681     -562.08438     -562.08438    
Loop time of 146.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.593 hours/ns, 6.843 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 145.62     | 145.62     | 145.62     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096489   | 0.096489   | 0.096489   |   0.0 |  0.07
Output  | 0.00021816 | 0.00021816 | 0.00021816 |   0.0 |  0.00
Modify  | 0.36098    | 0.36098    | 0.36098    |   0.0 |  0.25
Other   |            | 0.05875    |            |       |  0.04

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

Total # of neighbors = 206356
Ave neighs/atom = 103.178
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.441952107759, Press = -4.17953463530997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8036.4223     -8036.4223     -8117.5271     -8117.5271      313.88389      313.88389      24181.681      24181.681     -562.08438     -562.08438    
     24000  -8032.8507     -8032.8507     -8114.33       -8114.33        315.33354      315.33354      24149.156      24149.156      2743.9393      2743.9393    
Loop time of 169.63 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.119 hours/ns, 5.895 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.02     | 169.02     | 169.02     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10777    | 0.10777    | 0.10777    |   0.0 |  0.06
Output  | 0.00019784 | 0.00019784 | 0.00019784 |   0.0 |  0.00
Modify  | 0.43749    | 0.43749    | 0.43749    |   0.0 |  0.26
Other   |            | 0.06539    |            |       |  0.04

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

Total # of neighbors = 206622
Ave neighs/atom = 103.311
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.452568243515, Press = -0.56030929239591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8032.8507     -8032.8507     -8114.33       -8114.33        315.33354      315.33354      24149.156      24149.156      2743.9393      2743.9393    
     25000  -8036.7576     -8036.7576     -8115.4104     -8115.4104      304.39452      304.39452      24190.815      24190.815     -860.24847     -860.24847    
Loop time of 160.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.537 ns/day, 44.695 hours/ns, 6.215 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 160.32     | 160.32     | 160.32     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1047     | 0.1047     | 0.1047     |   0.0 |  0.07
Output  | 0.00017091 | 0.00017091 | 0.00017091 |   0.0 |  0.00
Modify  | 0.4119     | 0.4119     | 0.4119     |   0.0 |  0.26
Other   |            | 0.06322    |            |       |  0.04

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

Total # of neighbors = 207226
Ave neighs/atom = 103.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.471117562208, Press = 1.45988415926359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8036.7576     -8036.7576     -8115.4104     -8115.4104      304.39452      304.39452      24190.815      24190.815     -860.24847     -860.24847    
     26000  -8033.9972     -8033.9972     -8114.5972     -8114.5972      311.93039      311.93039      24200.15       24200.15      -1569.5391     -1569.5391    
Loop time of 171.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.504 ns/day, 47.578 hours/ns, 5.838 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.66     | 170.66     | 170.66     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11042    | 0.11042    | 0.11042    |   0.0 |  0.06
Output  | 0.00021411 | 0.00021411 | 0.00021411 |   0.0 |  0.00
Modify  | 0.44272    | 0.44272    | 0.44272    |   0.0 |  0.26
Other   |            | 0.06692    |            |       |  0.04

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

Total # of neighbors = 206296
Ave neighs/atom = 103.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.459608239065, Press = -3.71684779084348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8033.9972     -8033.9972     -8114.5972     -8114.5972      311.93039      311.93039      24200.15       24200.15      -1569.5391     -1569.5391    
     27000  -8037.2105     -8037.2105     -8116.9565     -8116.9565      308.6252       308.6252       24145.424      24145.424      2339.971       2339.971     
Loop time of 171.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.505 ns/day, 47.535 hours/ns, 5.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.51     | 170.51     | 170.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10884    | 0.10884    | 0.10884    |   0.0 |  0.06
Output  | 0.00017047 | 0.00017047 | 0.00017047 |   0.0 |  0.00
Modify  | 0.44105    | 0.44105    | 0.44105    |   0.0 |  0.26
Other   |            | 0.06556    |            |       |  0.04

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

Total # of neighbors = 206204
Ave neighs/atom = 103.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.365076514807, Press = -1.55202116724096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8037.2105     -8037.2105     -8116.9565     -8116.9565      308.6252       308.6252       24145.424      24145.424      2339.971       2339.971     
     28000  -8036.2423     -8036.2423     -8118.6231     -8118.6231      318.82217      318.82217      24182.995      24182.995     -743.4014      -743.4014     
Loop time of 158.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.923 hours/ns, 6.324 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.56     | 157.56     | 157.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10234    | 0.10234    | 0.10234    |   0.0 |  0.06
Output  | 0.00017048 | 0.00017048 | 0.00017048 |   0.0 |  0.00
Modify  | 0.40034    | 0.40034    | 0.40034    |   0.0 |  0.25
Other   |            | 0.06292    |            |       |  0.04

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

Total # of neighbors = 207266
Ave neighs/atom = 103.633
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.361717480526, Press = 0.949727132342434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8036.2423     -8036.2423     -8118.6231     -8118.6231      318.82217      318.82217      24182.995      24182.995     -743.4014      -743.4014     
     29000  -8032.6877     -8032.6877     -8116.47       -8116.47        324.24631      324.24631      24200.289      24200.289     -1586.2497     -1586.2497    
Loop time of 170.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.428 hours/ns, 5.857 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.13     | 170.13     | 170.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10916    | 0.10916    | 0.10916    |   0.0 |  0.06
Output  | 0.0002048  | 0.0002048  | 0.0002048  |   0.0 |  0.00
Modify  | 0.44007    | 0.44007    | 0.44007    |   0.0 |  0.26
Other   |            | 0.06558    |            |       |  0.04

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

Total # of neighbors = 206948
Ave neighs/atom = 103.474
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.355337450119, Press = -2.40647268760254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8032.6877     -8032.6877     -8116.47       -8116.47        324.24631      324.24631      24200.289      24200.289     -1586.2497     -1586.2497    
     30000  -8035.4617     -8035.4617     -8116.1841     -8116.1841      312.40404      312.40404      24140.865      24140.865      2936.7731      2936.7731    
Loop time of 170.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.374 hours/ns, 5.864 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.93     | 169.93     | 169.93     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10892    | 0.10892    | 0.10892    |   0.0 |  0.06
Output  | 0.00016981 | 0.00016981 | 0.00016981 |   0.0 |  0.00
Modify  | 0.43979    | 0.43979    | 0.43979    |   0.0 |  0.26
Other   |            | 0.06564    |            |       |  0.04

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

Total # of neighbors = 206214
Ave neighs/atom = 103.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.434923362081, Press = -1.86467724825808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8035.4617     -8035.4617     -8116.1841     -8116.1841      312.40404      312.40404      24140.865      24140.865      2936.7731      2936.7731    
     31000  -8034.9569     -8034.9569     -8116.1228     -8116.1228      314.12064      314.12064      24173.701      24173.701      307.12813      307.12813    
Loop time of 156.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.552 ns/day, 43.479 hours/ns, 6.389 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.97     | 155.97     | 155.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10025    | 0.10025    | 0.10025    |   0.0 |  0.06
Output  | 0.00021412 | 0.00021412 | 0.00021412 |   0.0 |  0.00
Modify  | 0.39296    | 0.39296    | 0.39296    |   0.0 |  0.25
Other   |            | 0.06197    |            |       |  0.04

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

Total # of neighbors = 207446
Ave neighs/atom = 103.723
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.593578260859, Press = 3.34783819994711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8034.9569     -8034.9569     -8116.1228     -8116.1228      314.12064      314.12064      24173.701      24173.701      307.12813      307.12813    
     32000  -8033.131      -8033.131      -8115.33       -8115.33        318.11874      318.11874      24205.473      24205.473     -1929.3449     -1929.3449    
Loop time of 171.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.706 hours/ns, 5.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.13     | 171.13     | 171.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10876    | 0.10876    | 0.10876    |   0.0 |  0.06
Output  | 0.00017176 | 0.00017176 | 0.00017176 |   0.0 |  0.00
Modify  | 0.43962    | 0.43962    | 0.43962    |   0.0 |  0.26
Other   |            | 0.06603    |            |       |  0.04

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

Total # of neighbors = 206766
Ave neighs/atom = 103.383
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.638742626187, Press = -1.44146467765796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8033.131      -8033.131      -8115.33       -8115.33        318.11874      318.11874      24205.473      24205.473     -1929.3449     -1929.3449    
     33000  -8038.1634     -8038.1634     -8118.632      -8118.632       311.42177      311.42177      24172.988      24172.988     -119.55897     -119.55897    
Loop time of 167.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.517 ns/day, 46.423 hours/ns, 5.984 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 166.52     | 166.52     | 166.52     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1067     | 0.1067     | 0.1067     |   0.0 |  0.06
Output  | 0.00025589 | 0.00025589 | 0.00025589 |   0.0 |  0.00
Modify  | 0.42915    | 0.42915    | 0.42915    |   0.0 |  0.26
Other   |            | 0.06539    |            |       |  0.04

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

Total # of neighbors = 206014
Ave neighs/atom = 103.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.721657686938, Press = -1.63323482137752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8038.1634     -8038.1634     -8118.632      -8118.632       311.42177      311.42177      24172.988      24172.988     -119.55897     -119.55897    
     34000  -8035.8801     -8035.8801     -8118.0802     -8118.0802      318.12287      318.12287      24165.505      24165.505      840.9759       840.9759     
Loop time of 166.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.192 hours/ns, 6.014 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.7      | 165.7      | 165.7      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10621    | 0.10621    | 0.10621    |   0.0 |  0.06
Output  | 0.00016792 | 0.00016792 | 0.00016792 |   0.0 |  0.00
Modify  | 0.42364    | 0.42364    | 0.42364    |   0.0 |  0.25
Other   |            | 0.0646     |            |       |  0.04

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

Total # of neighbors = 206816
Ave neighs/atom = 103.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.70873449207, Press = -0.211285022618873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8035.8801     -8035.8801     -8118.0802     -8118.0802      318.12287      318.12287      24165.505      24165.505      840.9759       840.9759     
     35000  -8035.7748     -8035.7748     -8118.6227     -8118.6227      320.62989      320.62989      24191.279      24191.279     -1451.7154     -1451.7154    
Loop time of 152.202 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.278 hours/ns, 6.570 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.66     | 151.66     | 151.66     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099833   | 0.099833   | 0.099833   |   0.0 |  0.07
Output  | 0.0001679  | 0.0001679  | 0.0001679  |   0.0 |  0.00
Modify  | 0.38061    | 0.38061    | 0.38061    |   0.0 |  0.25
Other   |            | 0.06041    |            |       |  0.04

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

Total # of neighbors = 207336
Ave neighs/atom = 103.668
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.629988240905, Press = 0.382966005224623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8035.7748     -8035.7748     -8118.6227     -8118.6227      320.62989      320.62989      24191.279      24191.279     -1451.7154     -1451.7154    
     36000  -8037.5442     -8037.5442     -8117.7397     -8117.7397      310.36481      310.36481      24182.121      24182.121     -636.28093     -636.28093    
Loop time of 165.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.521 ns/day, 46.029 hours/ns, 6.035 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.1      | 165.1      | 165.1      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10731    | 0.10731    | 0.10731    |   0.0 |  0.06
Output  | 0.00016989 | 0.00016989 | 0.00016989 |   0.0 |  0.00
Modify  | 0.42574    | 0.42574    | 0.42574    |   0.0 |  0.26
Other   |            | 0.06529    |            |       |  0.04

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

Total # of neighbors = 206658
Ave neighs/atom = 103.329
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.675150950923, Press = -2.95441683255392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8037.5442     -8037.5442     -8117.7397     -8117.7397      310.36481      310.36481      24182.121      24182.121     -636.28093     -636.28093    
     37000  -8035.1728     -8035.1728     -8117.9343     -8117.9343      320.29541      320.29541      24135.367      24135.367      2958.0243      2958.0243    
Loop time of 150.197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.721 hours/ns, 6.658 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.66     | 149.66     | 149.66     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098114   | 0.098114   | 0.098114   |   0.0 |  0.07
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.3743     | 0.3743     | 0.3743     |   0.0 |  0.25
Other   |            | 0.0614     |            |       |  0.04

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

Total # of neighbors = 206812
Ave neighs/atom = 103.406
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.796168082813, Press = 0.0064996255204511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8035.1728     -8035.1728     -8117.9343     -8117.9343      320.29541      320.29541      24135.367      24135.367      2958.0243      2958.0243    
     38000  -8032.7368     -8032.7368     -8115.699      -8115.699       321.07228      321.07228      24208.417      24208.417     -2173.3199     -2173.3199    
Loop time of 168.825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.896 hours/ns, 5.923 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.22     | 168.22     | 168.22     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1079     | 0.1079     | 0.1079     |   0.0 |  0.06
Output  | 0.00020551 | 0.00020551 | 0.00020551 |   0.0 |  0.00
Modify  | 0.43455    | 0.43455    | 0.43455    |   0.0 |  0.26
Other   |            | 0.0654     |            |       |  0.04

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

Total # of neighbors = 207690
Ave neighs/atom = 103.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 = 312.843504074329, Press = 0.846220300665265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8032.7368     -8032.7368     -8115.699      -8115.699       321.07228      321.07228      24208.417      24208.417     -2173.3199     -2173.3199    
     39000  -8037.3477     -8037.3477     -8116.6204     -8116.6204      306.79367      306.79367      24187.926      24187.926     -1012.8582     -1012.8582    
Loop time of 170.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.417 hours/ns, 5.858 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.08     | 170.08     | 170.08     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10987    | 0.10987    | 0.10987    |   0.0 |  0.06
Output  | 0.0001663  | 0.0001663  | 0.0001663  |   0.0 |  0.00
Modify  | 0.44394    | 0.44394    | 0.44394    |   0.0 |  0.26
Other   |            | 0.0652     |            |       |  0.04

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

Total # of neighbors = 205974
Ave neighs/atom = 102.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853832226915, Press = -2.8186729057809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8037.3477     -8037.3477     -8116.6204     -8116.6204      306.79367      306.79367      24187.926      24187.926     -1012.8582     -1012.8582    
     40000  -8034.1324     -8034.1324     -8115.9168     -8115.9168      316.51417      316.51417      24152.036      24152.036      2064.4105      2064.4105    
Loop time of 168.839 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.900 hours/ns, 5.923 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.23     | 168.23     | 168.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10792    | 0.10792    | 0.10792    |   0.0 |  0.06
Output  | 0.00020676 | 0.00020676 | 0.00020676 |   0.0 |  0.00
Modify  | 0.4328     | 0.4328     | 0.4328     |   0.0 |  0.26
Other   |            | 0.06339    |            |       |  0.04

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

Total # of neighbors = 206468
Ave neighs/atom = 103.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.774896440348, Press = -0.34386560018412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8034.1324     -8034.1324     -8115.9168     -8115.9168      316.51417      316.51417      24152.036      24152.036      2064.4105      2064.4105    
     41000  -8037.1003     -8037.1003     -8115.8876     -8115.8876      304.91503      304.91503      24181.019      24181.019     -266.88282     -266.88282    
Loop time of 156.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.553 ns/day, 43.426 hours/ns, 6.397 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.78     | 155.78     | 155.78     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1013     | 0.1013     | 0.1013     |   0.0 |  0.06
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.39286    | 0.39286    | 0.39286    |   0.0 |  0.25
Other   |            | 0.06126    |            |       |  0.04

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

Total # of neighbors = 207030
Ave neighs/atom = 103.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.78101319246, Press = 0.281018968574841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8037.1003     -8037.1003     -8115.8876     -8115.8876      304.91503      304.91503      24181.019      24181.019     -266.88282     -266.88282    
     42000  -8033.7763     -8033.7763     -8116.5738     -8116.5738      320.4351       320.4351       24190.742      24190.742     -935.77613     -935.77613    
Loop time of 164.725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.525 ns/day, 45.757 hours/ns, 6.071 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 164.13     | 164.13     | 164.13     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10571    | 0.10571    | 0.10571    |   0.0 |  0.06
Output  | 0.00021699 | 0.00021699 | 0.00021699 |   0.0 |  0.00
Modify  | 0.42217    | 0.42217    | 0.42217    |   0.0 |  0.26
Other   |            | 0.06387    |            |       |  0.04

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

Total # of neighbors = 206564
Ave neighs/atom = 103.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.800738698165, Press = -1.21948545766577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8033.7763     -8033.7763     -8116.5738     -8116.5738      320.4351       320.4351       24190.742      24190.742     -935.77613     -935.77613    
     43000  -8034.6839     -8034.6839     -8118.0467     -8118.0467      322.623        322.623        24171.226      24171.226      466.33463      466.33463    
Loop time of 170.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.460 hours/ns, 5.853 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.24     | 170.24     | 170.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10839    | 0.10839    | 0.10839    |   0.0 |  0.06
Output  | 0.0002007  | 0.0002007  | 0.0002007  |   0.0 |  0.00
Modify  | 0.44009    | 0.44009    | 0.44009    |   0.0 |  0.26
Other   |            | 0.06555    |            |       |  0.04

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

Total # of neighbors = 206458
Ave neighs/atom = 103.229
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.878570325843, Press = -0.984454436913494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8034.6839     -8034.6839     -8118.0467     -8118.0467      322.623        322.623        24171.226      24171.226      466.33463      466.33463    
     44000  -8034.1936     -8034.1936     -8116.7124     -8116.7124      319.35645      319.35645      24185.949      24185.949     -535.76209     -535.76209    
Loop time of 170.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.322 hours/ns, 5.870 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.74     | 169.74     | 169.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10782    | 0.10782    | 0.10782    |   0.0 |  0.06
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.44435    | 0.44435    | 0.44435    |   0.0 |  0.26
Other   |            | 0.06595    |            |       |  0.04

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

Total # of neighbors = 206944
Ave neighs/atom = 103.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.914653768639, Press = -0.604353302547101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8034.1936     -8034.1936     -8116.7124     -8116.7124      319.35645      319.35645      24185.949      24185.949     -535.76209     -535.76209    
     45000  -8037.0225     -8037.0225     -8117.6603     -8117.6603      312.07652      312.07652      24183.018      24183.018     -546.74037     -546.74037    
Loop time of 170.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.337 hours/ns, 5.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.79     | 169.79     | 169.79     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10857    | 0.10857    | 0.10857    |   0.0 |  0.06
Output  | 0.00021868 | 0.00021868 | 0.00021868 |   0.0 |  0.00
Modify  | 0.44297    | 0.44297    | 0.44297    |   0.0 |  0.26
Other   |            | 0.06556    |            |       |  0.04

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

Total # of neighbors = 206418
Ave neighs/atom = 103.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.993302049298, Press = -1.04418694610777
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8037.0225     -8037.0225     -8117.6603     -8117.6603      312.07652      312.07652      24183.018      24183.018     -546.74037     -546.74037    
     46000  -8033.9259     -8033.9259     -8115.5073     -8115.5073      315.72826      315.72826      24182.71       24182.71      -122.58522     -122.58522    
Loop time of 170.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.374 hours/ns, 5.864 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.93     | 169.93     | 169.93     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10735    | 0.10735    | 0.10735    |   0.0 |  0.06
Output  | 0.00021658 | 0.00021658 | 0.00021658 |   0.0 |  0.00
Modify  | 0.43893    | 0.43893    | 0.43893    |   0.0 |  0.26
Other   |            | 0.0643     |            |       |  0.04

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

Total # of neighbors = 206716
Ave neighs/atom = 103.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.010459047223, Press = -1.23558323631377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8033.9259     -8033.9259     -8115.5073     -8115.5073      315.72826      315.72826      24182.71       24182.71      -122.58522     -122.58522    
     47000  -8035.5169     -8035.5169     -8113.5501     -8113.5501      301.99671      301.99671      24160.399      24160.399      1952.4611      1952.4611    
Loop time of 144.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.272 hours/ns, 6.897 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.47     | 144.47     | 144.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095088   | 0.095088   | 0.095088   |   0.0 |  0.07
Output  | 0.0001723  | 0.0001723  | 0.0001723  |   0.0 |  0.00
Modify  | 0.35853    | 0.35853    | 0.35853    |   0.0 |  0.25
Other   |            | 0.05803    |            |       |  0.04

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

Total # of neighbors = 206606
Ave neighs/atom = 103.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.948912786591, Press = 0.450675453303849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8035.5169     -8035.5169     -8113.5501     -8113.5501      301.99671      301.99671      24160.399      24160.399      1952.4611      1952.4611    
     48000  -8034.7725     -8034.7725     -8117.3166     -8117.3166      319.45427      319.45427      24221.164      24221.164     -3601.4791     -3601.4791    
Loop time of 144.57 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.158 hours/ns, 6.917 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.06     | 144.06     | 144.06     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095104   | 0.095104   | 0.095104   |   0.0 |  0.07
Output  | 0.00017054 | 0.00017054 | 0.00017054 |   0.0 |  0.00
Modify  | 0.35615    | 0.35615    | 0.35615    |   0.0 |  0.25
Other   |            | 0.058      |            |       |  0.04

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

Total # of neighbors = 206878
Ave neighs/atom = 103.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.924640968862, Press = -0.949956180988761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8034.7725     -8034.7725     -8117.3166     -8117.3166      319.45427      319.45427      24221.164      24221.164     -3601.4791     -3601.4791    
     49000  -8033.4229     -8033.4229     -8115.1948     -8115.1948      316.46565      316.46565      24168.33       24168.33       1237.4407      1237.4407    
Loop time of 144.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.217 hours/ns, 6.907 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.27     | 144.27     | 144.27     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095292   | 0.095292   | 0.095292   |   0.0 |  0.07
Output  | 0.00017564 | 0.00017564 | 0.00017564 |   0.0 |  0.00
Modify  | 0.35605    | 0.35605    | 0.35605    |   0.0 |  0.25
Other   |            | 0.05832    |            |       |  0.04

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

Total # of neighbors = 205808
Ave neighs/atom = 102.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.896483338084, Press = -2.9496329792949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8033.4229     -8033.4229     -8115.1948     -8115.1948      316.46565      316.46565      24168.33       24168.33       1237.4407      1237.4407    
     50000  -8037.0759     -8037.0759     -8116.7403     -8116.7403      308.30939      308.30939      24150.501      24150.501      1907.4565      1907.4565    
Loop time of 144.849 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.236 hours/ns, 6.904 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.34     | 144.34     | 144.34     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094364   | 0.094364   | 0.094364   |   0.0 |  0.07
Output  | 0.00020077 | 0.00020077 | 0.00020077 |   0.0 |  0.00
Modify  | 0.35625    | 0.35625    | 0.35625    |   0.0 |  0.25
Other   |            | 0.05883    |            |       |  0.04

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

Total # of neighbors = 206864
Ave neighs/atom = 103.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.930221551222, Press = -0.0138670803023382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8037.0759     -8037.0759     -8116.7403     -8116.7403      308.30939      308.30939      24150.501      24150.501      1907.4565      1907.4565    
     51000  -8032.8004     -8032.8004     -8112.0516     -8112.0516      306.71043      306.71043      24194.112      24194.112     -437.93922     -437.93922    
Loop time of 144.854 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.596 ns/day, 40.237 hours/ns, 6.903 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.34     | 144.34     | 144.34     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094616   | 0.094616   | 0.094616   |   0.0 |  0.07
Output  | 0.00016899 | 0.00016899 | 0.00016899 |   0.0 |  0.00
Modify  | 0.35696    | 0.35696    | 0.35696    |   0.0 |  0.25
Other   |            | 0.05771    |            |       |  0.04

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

Total # of neighbors = 207188
Ave neighs/atom = 103.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.994942018834, Press = -0.539407049462558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8032.8004     -8032.8004     -8112.0516     -8112.0516      306.71043      306.71043      24194.112      24194.112     -437.93922     -437.93922    
     52000  -8036.6114     -8036.6114     -8116.1129     -8116.1129      307.67911      307.67911      24171.725      24171.725      417.55031      417.55031    
Loop time of 144.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.166 hours/ns, 6.916 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.09     | 144.09     | 144.09     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095058   | 0.095058   | 0.095058   |   0.0 |  0.07
Output  | 0.00017586 | 0.00017586 | 0.00017586 |   0.0 |  0.00
Modify  | 0.35602    | 0.35602    | 0.35602    |   0.0 |  0.25
Other   |            | 0.05877    |            |       |  0.04

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

Total # of neighbors = 205996
Ave neighs/atom = 102.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.006478339015, Press = -1.41896245090408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8036.6114     -8036.6114     -8116.1129     -8116.1129      307.67911      307.67911      24171.725      24171.725      417.55031      417.55031    
     53000  -8035.3939     -8035.3939     -8116.9314     -8116.9314      315.55883      315.55883      24170.276      24170.276      578.55478      578.55478    
Loop time of 144.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.597 ns/day, 40.203 hours/ns, 6.909 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.22     | 144.22     | 144.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095257   | 0.095257   | 0.095257   |   0.0 |  0.07
Output  | 0.00016939 | 0.00016939 | 0.00016939 |   0.0 |  0.00
Modify  | 0.35619    | 0.35619    | 0.35619    |   0.0 |  0.25
Other   |            | 0.05862    |            |       |  0.04

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

Total # of neighbors = 206808
Ave neighs/atom = 103.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
24178.0556688829

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0