# 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 3.6200000196695328*${_u_distance}
variable latticeconst_converted equal 3.6200000196695328*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62000001966953
Lattice spacing in x,y,z = 3.62 3.62 3.62
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JelinekGrohHorstemeyer_2012_AlSiMgCuFe__MO_262519520678_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47437.9287732722 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 273.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "273.15 - 0.2"
variable      T_up  equal  "273.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_262519520678_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47437.929      47437.929      3179.1329      3179.1329    
      1000  -13865.677     -13865.677     -14003.385     -14003.385      266.40563      266.40563      48111.94       48111.94      -632.22006     -632.22006    
Loop time of 100.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.860 ns/day, 27.914 hours/ns, 9.951 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.34     | 100.34     | 100.34     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022065   | 0.022065   | 0.022065   |   0.0 |  0.02
Output  | 0.00016044 | 0.00016044 | 0.00016044 |   0.0 |  0.00
Modify  | 0.11875    | 0.11875    | 0.11875    |   0.0 |  0.12
Other   |            | 0.01077    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13865.677     -13865.677     -14003.385     -14003.385      266.40563      266.40563      48111.94       48111.94      -632.22006     -632.22006    
      2000  -13877.354     -13877.354     -14017.143     -14017.143      270.43035      270.43035      48032.607      48032.607      313.42274      313.42274    
Loop time of 103.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.818 hours/ns, 9.639 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.59     | 103.59     | 103.59     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021913   | 0.021913   | 0.021913   |   0.0 |  0.02
Output  | 6.3229e-05 | 6.3229e-05 | 6.3229e-05 |   0.0 |  0.00
Modify  | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.11
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       528676 ave      528676 max      528676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 528676
Ave neighs/atom = 132.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13877.354     -13877.354     -14017.143     -14017.143      270.43035      270.43035      48032.607      48032.607      313.42274      313.42274    
      3000  -13872.345     -13872.345     -14015.554     -14015.554      277.04919      277.04919      48077.332      48077.332     -810.72027     -810.72027    
Loop time of 104.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.958 hours/ns, 9.592 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.1      | 104.1      | 104.1      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021909   | 0.021909   | 0.021909   |   0.0 |  0.02
Output  | 7.1485e-05 | 7.1485e-05 | 7.1485e-05 |   0.0 |  0.00
Modify  | 0.11847    | 0.11847    | 0.11847    |   0.0 |  0.11
Other   |            | 0.01047    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530922 ave      530922 max      530922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530922
Ave neighs/atom = 132.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13872.345     -13872.345     -14015.554     -14015.554      277.04919      277.04919      48077.332      48077.332     -810.72027     -810.72027    
      4000  -13876.598     -13876.598     -14015.77      -14015.77       269.23595      269.23595      48032.636      48032.636      454.61868      454.61868    
Loop time of 104.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.058 hours/ns, 9.559 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.46     | 104.46     | 104.46     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022051   | 0.022051   | 0.022051   |   0.0 |  0.02
Output  | 7.8227e-05 | 7.8227e-05 | 7.8227e-05 |   0.0 |  0.00
Modify  | 0.11923    | 0.11923    | 0.11923    |   0.0 |  0.11
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530224 ave      530224 max      530224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530224
Ave neighs/atom = 132.556
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13876.598     -13876.598     -14015.77      -14015.77       269.23595      269.23595      48032.636      48032.636      454.61868      454.61868    
      5000  -13870.636     -13870.636     -14015.84      -14015.84       280.90704      280.90704      48083.646      48083.646     -813.19474     -813.19474    
Loop time of 104.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.034 hours/ns, 9.567 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.37     | 104.37     | 104.37     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023097   | 0.023097   | 0.023097   |   0.0 |  0.02
Output  | 4.9943e-05 | 4.9943e-05 | 4.9943e-05 |   0.0 |  0.00
Modify  | 0.11966    | 0.11966    | 0.11966    |   0.0 |  0.11
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530654 ave      530654 max      530654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530654
Ave neighs/atom = 132.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.948889553563, Press = -70.7120240063429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13870.636     -13870.636     -14015.84      -14015.84       280.90704      280.90704      48083.646      48083.646     -813.19474     -813.19474    
      6000  -13877.756     -13877.756     -14020.399     -14020.399      275.9536       275.9536       48007.38       48007.38       872.03437      872.03437    
Loop time of 104.578 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.049 hours/ns, 9.562 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.42     | 104.42     | 104.42     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022745   | 0.022745   | 0.022745   |   0.0 |  0.02
Output  | 4.8662e-05 | 4.8662e-05 | 4.8662e-05 |   0.0 |  0.00
Modify  | 0.12267    | 0.12267    | 0.12267    |   0.0 |  0.12
Other   |            | 0.01064    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530514 ave      530514 max      530514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530514
Ave neighs/atom = 132.6285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.247144359359, Press = 25.8997251995005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13877.756     -13877.756     -14020.399     -14020.399      275.9536       275.9536       48007.38       48007.38       872.03437      872.03437    
      7000  -13870.92      -13870.92      -14011.651     -14011.651      272.25412      272.25412      48029.97       48029.97       950.98448      950.98448    
Loop time of 104.688 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.080 hours/ns, 9.552 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022106   | 0.022106   | 0.022106   |   0.0 |  0.02
Output  | 5.4062e-05 | 5.4062e-05 | 5.4062e-05 |   0.0 |  0.00
Modify  | 0.1229     | 0.1229     | 0.1229     |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       531522 ave      531522 max      531522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531522
Ave neighs/atom = 132.8805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.204156394564, Press = -34.7228564033219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13870.92      -13870.92      -14011.651     -14011.651      272.25412      272.25412      48029.97       48029.97       950.98448      950.98448    
      8000  -13874.46      -13874.46      -14015.615     -14015.615      273.07346      273.07346      48096.964      48096.964     -1323.1653     -1323.1653    
Loop time of 104.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.032 hours/ns, 9.568 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.36     | 104.36     | 104.36     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022933   | 0.022933   | 0.022933   |   0.0 |  0.02
Output  | 5.4913e-05 | 5.4913e-05 | 5.4913e-05 |   0.0 |  0.00
Modify  | 0.12267    | 0.12267    | 0.12267    |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530542 ave      530542 max      530542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530542
Ave neighs/atom = 132.6355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.206504632257, Press = 0.525944467995645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13874.46      -13874.46      -14015.615     -14015.615      273.07346      273.07346      48096.964      48096.964     -1323.1653     -1323.1653    
      9000  -13876.89      -13876.89      -14018.103     -14018.103      273.18491      273.18491      48029.135      48029.135      313.17977      313.17977    
Loop time of 104.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.094 hours/ns, 9.548 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023169   | 0.023169   | 0.023169   |   0.0 |  0.02
Output  | 5.3761e-05 | 5.3761e-05 | 5.3761e-05 |   0.0 |  0.00
Modify  | 0.1228     | 0.1228     | 0.1228     |   0.0 |  0.12
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530198 ave      530198 max      530198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530198
Ave neighs/atom = 132.5495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.254167016007, Press = 5.5448258509066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13876.89      -13876.89      -14018.103     -14018.103      273.18491      273.18491      48029.135      48029.135      313.17977      313.17977    
     10000  -13871.25      -13871.25      -14011.635     -14011.635      271.58577      271.58577      48050.692      48050.692      290.96584      290.96584    
Loop time of 104.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.84     | 104.84     | 104.84     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022762   | 0.022762   | 0.022762   |   0.0 |  0.02
Output  | 5.0906e-05 | 5.0906e-05 | 5.0906e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530842 ave      530842 max      530842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530842
Ave neighs/atom = 132.7105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.319015632144, Press = -4.01139265874678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13871.25      -13871.25      -14011.635     -14011.635      271.58577      271.58577      48050.692      48050.692      290.96584      290.96584    
     11000  -13876.392     -13876.392     -14017.15      -14017.15       272.30585      272.30585      48073.432      48073.432     -786.21403     -786.21403    
Loop time of 104.663 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.073 hours/ns, 9.554 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.51     | 104.51     | 104.51     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021945   | 0.021945   | 0.021945   |   0.0 |  0.02
Output  | 5.1637e-05 | 5.1637e-05 | 5.1637e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530244 ave      530244 max      530244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530244
Ave neighs/atom = 132.561
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.436232157587, Press = 0.679730875830942
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13876.392     -13876.392     -14017.15      -14017.15       272.30585      272.30585      48073.432      48073.432     -786.21403     -786.21403    
     12000  -13876.878     -13876.878     -14018.614     -14018.614      274.19666      274.19666      48013.093      48013.093      809.29585      809.29585    
Loop time of 105.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.822 ns/day, 29.187 hours/ns, 9.517 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.92     | 104.92     | 104.92     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022192   | 0.022192   | 0.022192   |   0.0 |  0.02
Output  | 5.2218e-05 | 5.2218e-05 | 5.2218e-05 |   0.0 |  0.00
Modify  | 0.12297    | 0.12297    | 0.12297    |   0.0 |  0.12
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530618 ave      530618 max      530618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530618
Ave neighs/atom = 132.6545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454120453668, Press = 4.38595642578033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13876.878     -13876.878     -14018.614     -14018.614      274.19666      274.19666      48013.093      48013.093      809.29585      809.29585    
     13000  -13873.982     -13873.982     -14014.967     -14014.967      272.74492      272.74492      48015.069      48015.069      1072.9983      1072.9983    
Loop time of 104.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.095 hours/ns, 9.547 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023163   | 0.023163   | 0.023163   |   0.0 |  0.02
Output  | 5.2108e-05 | 5.2108e-05 | 5.2108e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01062    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       531196 ave      531196 max      531196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531196
Ave neighs/atom = 132.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.448980673236, Press = -8.58526181497342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13873.982     -13873.982     -14014.967     -14014.967      272.74492      272.74492      48015.069      48015.069      1072.9983      1072.9983    
     14000  -13873.453     -13873.453     -14015.463     -14015.463      274.7268       274.7268       48122.481      48122.481     -1960.3658     -1960.3658    
Loop time of 104.848 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.124 hours/ns, 9.538 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.69     | 104.69     | 104.69     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023036   | 0.023036   | 0.023036   |   0.0 |  0.02
Output  | 0.00012817 | 0.00012817 | 0.00012817 |   0.0 |  0.00
Modify  | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.12
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530958 ave      530958 max      530958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530958
Ave neighs/atom = 132.7395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.470914423974, Press = -0.0118029335334828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13873.453     -13873.453     -14015.463     -14015.463      274.7268       274.7268       48122.481      48122.481     -1960.3658     -1960.3658    
     15000  -13870.828     -13870.828     -14013.861     -14013.861      276.70627      276.70627      48055.085      48055.085      126.10076      126.10076    
Loop time of 104.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.084 hours/ns, 9.551 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.55     | 104.55     | 104.55     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022177   | 0.022177   | 0.022177   |   0.0 |  0.02
Output  | 5.1005e-05 | 5.1005e-05 | 5.1005e-05 |   0.0 |  0.00
Modify  | 0.12318    | 0.12318    | 0.12318    |   0.0 |  0.12
Other   |            | 0.01067    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530300 ave      530300 max      530300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530300
Ave neighs/atom = 132.575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.688688518682, Press = 3.6574640835469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13870.828     -13870.828     -14013.861     -14013.861      276.70627      276.70627      48055.085      48055.085      126.10076      126.10076    
     16000  -13872.242     -13872.242     -14015.328     -14015.328      276.8101       276.8101       48012.41       48012.41       1135.9679      1135.9679    
Loop time of 104.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.108 hours/ns, 9.543 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.63     | 104.63     | 104.63     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022007   | 0.022007   | 0.022007   |   0.0 |  0.02
Output  | 5.6386e-05 | 5.6386e-05 | 5.6386e-05 |   0.0 |  0.00
Modify  | 0.12336    | 0.12336    | 0.12336    |   0.0 |  0.12
Other   |            | 0.01078    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530320 ave      530320 max      530320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530320
Ave neighs/atom = 132.58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.623824684178, Press = -1.3270368752616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13872.242     -13872.242     -14015.328     -14015.328      276.8101       276.8101       48012.41       48012.41       1135.9679      1135.9679    
     17000  -13876.59      -13876.59      -14014.681     -14014.681      267.14683      267.14683      48087.483      48087.483     -1014.141      -1014.141     
Loop time of 104.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.110 hours/ns, 9.542 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.64     | 104.64     | 104.64     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022066   | 0.022066   | 0.022066   |   0.0 |  0.02
Output  | 5.0425e-05 | 5.0425e-05 | 5.0425e-05 |   0.0 |  0.00
Modify  | 0.12367    | 0.12367    | 0.12367    |   0.0 |  0.12
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530928 ave      530928 max      530928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530928
Ave neighs/atom = 132.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.60055323882, Press = -2.0544503960594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13876.59      -13876.59      -14014.681     -14014.681      267.14683      267.14683      48087.483      48087.483     -1014.141      -1014.141     
     18000  -13874.429     -13874.429     -14017.567     -14017.567      276.91115      276.91115      48052.895      48052.895     -224.29687     -224.29687    
Loop time of 105.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.240 hours/ns, 9.500 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.11     | 105.11     | 105.11     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023271   | 0.023271   | 0.023271   |   0.0 |  0.02
Output  | 5.8209e-05 | 5.8209e-05 | 5.8209e-05 |   0.0 |  0.00
Modify  | 0.12409    | 0.12409    | 0.12409    |   0.0 |  0.12
Other   |            | 0.01068    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529856 ave      529856 max      529856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529856
Ave neighs/atom = 132.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.464376561215, Press = 3.07465417762402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13874.429     -13874.429     -14017.567     -14017.567      276.91115      276.91115      48052.895      48052.895     -224.29687     -224.29687    
     19000  -13878.518     -13878.518     -14016.7       -14016.7        267.32303      267.32303      47936.438      47936.438      3076.9562      3076.9562    
Loop time of 104.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.84     | 104.84     | 104.84     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022164   | 0.022164   | 0.022164   |   0.0 |  0.02
Output  | 6.4561e-05 | 6.4561e-05 | 6.4561e-05 |   0.0 |  0.00
Modify  | 0.12375    | 0.12375    | 0.12375    |   0.0 |  0.12
Other   |            | 0.01092    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530758 ave      530758 max      530758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530758
Ave neighs/atom = 132.6895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.397804039259, Press = -1.38648498827764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13878.518     -13878.518     -14016.7       -14016.7        267.32303      267.32303      47936.438      47936.438      3076.9562      3076.9562    
     20000  -13871.819     -13871.819     -14013.978     -14013.978      275.01709      275.01709      48109.097      48109.097     -1508.0358     -1508.0358    
Loop time of 104.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.965 hours/ns, 9.590 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.12     | 104.12     | 104.12     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02209    | 0.02209    | 0.02209    |   0.0 |  0.02
Output  | 6.8378e-05 | 6.8378e-05 | 6.8378e-05 |   0.0 |  0.00
Modify  | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.12
Other   |            | 0.01089    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       531318 ave      531318 max      531318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531318
Ave neighs/atom = 132.8295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.261942499817, Press = -2.22914142941523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13871.819     -13871.819     -14013.978     -14013.978      275.01709      275.01709      48109.097      48109.097     -1508.0358     -1508.0358    
     21000  -13871.17      -13871.17      -14013.438     -14013.438      275.22636      275.22636      48067.539      48067.539     -179.59708     -179.59708    
Loop time of 104.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.930 hours/ns, 9.602 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.99     | 103.99     | 103.99     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023062   | 0.023062   | 0.023062   |   0.0 |  0.02
Output  | 5.6796e-05 | 5.6796e-05 | 5.6796e-05 |   0.0 |  0.00
Modify  | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.12
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529924 ave      529924 max      529924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529924
Ave neighs/atom = 132.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.256904946934, Press = 1.99103328822191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13871.17      -13871.17      -14013.438     -14013.438      275.22636      275.22636      48067.539      48067.539     -179.59708     -179.59708    
     22000  -13872.343     -13872.343     -14012.116     -14012.116      270.40183      270.40183      48010.829      48010.829      1485.0631      1485.0631    
Loop time of 104.278 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.966 hours/ns, 9.590 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.12     | 104.12     | 104.12     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022948   | 0.022948   | 0.022948   |   0.0 |  0.02
Output  | 5.2349e-05 | 5.2349e-05 | 5.2349e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.12
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530430 ave      530430 max      530430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530430
Ave neighs/atom = 132.6075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.206058350607, Press = -0.220230086404809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13872.343     -13872.343     -14012.116     -14012.116      270.40183      270.40183      48010.829      48010.829      1485.0631      1485.0631    
     23000  -13879.951     -13879.951     -14018.89      -14018.89       268.78712      268.78712      48059.8        48059.8       -612.76933     -612.76933    
Loop time of 104.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.951 hours/ns, 9.595 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.07     | 104.07     | 104.07     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022159   | 0.022159   | 0.022159   |   0.0 |  0.02
Output  | 5.2619e-05 | 5.2619e-05 | 5.2619e-05 |   0.0 |  0.00
Modify  | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.12
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530574 ave      530574 max      530574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530574
Ave neighs/atom = 132.6435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.131533996554, Press = -0.921120813554135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13879.951     -13879.951     -14018.89      -14018.89       268.78712      268.78712      48059.8        48059.8       -612.76933     -612.76933    
     24000  -13872.587     -13872.587     -14012.936     -14012.936      271.51441      271.51441      48081.932      48081.932     -610.47906     -610.47906    
Loop time of 104.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.012 hours/ns, 9.574 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.29     | 104.29     | 104.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022811   | 0.022811   | 0.022811   |   0.0 |  0.02
Output  | 5.9151e-05 | 5.9151e-05 | 5.9151e-05 |   0.0 |  0.00
Modify  | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.12
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530956 ave      530956 max      530956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530956
Ave neighs/atom = 132.739
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.092149630409, Press = 1.21170430190835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13872.587     -13872.587     -14012.936     -14012.936      271.51441      271.51441      48081.932      48081.932     -610.47906     -610.47906    
     25000  -13877.35      -13877.35      -14015.719     -14015.719      267.68384      267.68384      47954.121      47954.121      2644.4813      2644.4813    
Loop time of 104.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.030 hours/ns, 9.569 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.35     | 104.35     | 104.35     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02294    | 0.02294    | 0.02294    |   0.0 |  0.02
Output  | 5.311e-05  | 5.311e-05  | 5.311e-05  |   0.0 |  0.00
Modify  | 0.12287    | 0.12287    | 0.12287    |   0.0 |  0.12
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530374 ave      530374 max      530374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530374
Ave neighs/atom = 132.5935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.006330087501, Press = 1.41070367464567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13877.35      -13877.35      -14015.719     -14015.719      267.68384      267.68384      47954.121      47954.121      2644.4813      2644.4813    
     26000  -13872.709     -13872.709     -14013.871     -14013.871      273.08731      273.08731      48073.101      48073.101     -420.21347     -420.21347    
Loop time of 104.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.987 hours/ns, 9.583 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.2      | 104.2      | 104.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022115   | 0.022115   | 0.022115   |   0.0 |  0.02
Output  | 6.0073e-05 | 6.0073e-05 | 6.0073e-05 |   0.0 |  0.00
Modify  | 0.12286    | 0.12286    | 0.12286    |   0.0 |  0.12
Other   |            | 0.01073    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5846 ave        5846 max        5846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       531186 ave      531186 max      531186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531186
Ave neighs/atom = 132.7965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.951087968098, Press = -2.72857517060369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13872.709     -13872.709     -14013.871     -14013.871      273.08731      273.08731      48073.101      48073.101     -420.21347     -420.21347    
     27000  -13875.918     -13875.918     -14016.979     -14016.979      272.89177      272.89177      48084.659      48084.659     -1090.8445     -1090.8445    
Loop time of 104.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.010 hours/ns, 9.575 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.28     | 104.28     | 104.28     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02326    | 0.02326    | 0.02326    |   0.0 |  0.02
Output  | 5.4913e-05 | 5.4913e-05 | 5.4913e-05 |   0.0 |  0.00
Modify  | 0.12288    | 0.12288    | 0.12288    |   0.0 |  0.12
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530444 ave      530444 max      530444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530444
Ave neighs/atom = 132.611
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.916428170166, Press = 0.803451829016931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13875.918     -13875.918     -14016.979     -14016.979      272.89177      272.89177      48084.659      48084.659     -1090.8445     -1090.8445    
     28000  -13872.226     -13872.226     -14013.343     -14013.343      273.0012       273.0012       48044.688      48044.688      418.97688      418.97688    
Loop time of 104.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.976 hours/ns, 9.586 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.16     | 104.16     | 104.16     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022128   | 0.022128   | 0.022128   |   0.0 |  0.02
Output  | 5.5264e-05 | 5.5264e-05 | 5.5264e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.12
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530378 ave      530378 max      530378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530378
Ave neighs/atom = 132.5945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.895215348083, Press = 1.02694911517191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13872.226     -13872.226     -14013.343     -14013.343      273.0012       273.0012       48044.688      48044.688      418.97688      418.97688    
     29000  -13878.617     -13878.617     -14017.7       -14017.7        269.06491      269.06491      48009.453      48009.453      964.46117      964.46117    
Loop time of 104.118 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.922 hours/ns, 9.605 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.96     | 103.96     | 103.96     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021822   | 0.021822   | 0.021822   |   0.0 |  0.02
Output  | 4.8872e-05 | 4.8872e-05 | 4.8872e-05 |   0.0 |  0.00
Modify  | 0.12306    | 0.12306    | 0.12306    |   0.0 |  0.12
Other   |            | 0.01075    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530382 ave      530382 max      530382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530382
Ave neighs/atom = 132.5955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.859465689537, Press = -0.162288366925946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13878.617     -13878.617     -14017.7       -14017.7        269.06491      269.06491      48009.453      48009.453      964.46117      964.46117    
     30000  -13874.125     -13874.125     -14014.736     -14014.736      272.02019      272.02019      48074.705      48074.705     -563.89456     -563.89456    
Loop time of 104.283 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.829 ns/day, 28.967 hours/ns, 9.589 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.13     | 104.13     | 104.13     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021871   | 0.021871   | 0.021871   |   0.0 |  0.02
Output  | 5.3561e-05 | 5.3561e-05 | 5.3561e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.12
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530928 ave      530928 max      530928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530928
Ave neighs/atom = 132.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.845720085321, Press = -0.540316224654152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13874.125     -13874.125     -14014.736     -14014.736      272.02019      272.02019      48074.705      48074.705     -563.89456     -563.89456    
     31000  -13875.005     -13875.005     -14015.342     -14015.342      271.49239      271.49239      48081.195      48081.195     -827.14132     -827.14132    
Loop time of 104.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.925 hours/ns, 9.603 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.97     | 103.97     | 103.97     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02194    | 0.02194    | 0.02194    |   0.0 |  0.02
Output  | 5.0826e-05 | 5.0826e-05 | 5.0826e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.12
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530286 ave      530286 max      530286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530286
Ave neighs/atom = 132.5715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.872983624211, Press = 1.39198357904413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13875.005     -13875.005     -14015.342     -14015.342      271.49239      271.49239      48081.195      48081.195     -827.14132     -827.14132    
     32000  -13872.72      -13872.72      -14014.336     -14014.336      273.9661       273.9661       47990.945      47990.945      1840.2029      1840.2029    
Loop time of 104.491 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.025 hours/ns, 9.570 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.33     | 104.33     | 104.33     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022665   | 0.022665   | 0.022665   |   0.0 |  0.02
Output  | 5.0915e-05 | 5.0915e-05 | 5.0915e-05 |   0.0 |  0.00
Modify  | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.12
Other   |            | 0.01078    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530464 ave      530464 max      530464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530464
Ave neighs/atom = 132.616
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824809477991, Press = 0.692495582398955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13872.72      -13872.72      -14014.336     -14014.336      273.9661       273.9661       47990.945      47990.945      1840.2029      1840.2029    
     33000  -13877.318     -13877.318     -14017.806     -14017.806      271.78437      271.78437      48073.104      48073.104     -850.32577     -850.32577    
Loop time of 104.454 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.015 hours/ns, 9.574 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022467   | 0.022467   | 0.022467   |   0.0 |  0.02
Output  | 5.6396e-05 | 5.6396e-05 | 5.6396e-05 |   0.0 |  0.00
Modify  | 0.12289    | 0.12289    | 0.12289    |   0.0 |  0.12
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530596 ave      530596 max      530596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530596
Ave neighs/atom = 132.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.839415656833, Press = -1.53509417660895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13877.318     -13877.318     -14017.806     -14017.806      271.78437      271.78437      48073.104      48073.104     -850.32577     -850.32577    
     34000  -13873.986     -13873.986     -14014.179     -14014.179      271.21204      271.21204      48087.813      48087.813     -898.87452     -898.87452    
Loop time of 104.487 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.024 hours/ns, 9.571 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.33     | 104.33     | 104.33     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022366   | 0.022366   | 0.022366   |   0.0 |  0.02
Output  | 5.1146e-05 | 5.1146e-05 | 5.1146e-05 |   0.0 |  0.00
Modify  | 0.12293    | 0.12293    | 0.12293    |   0.0 |  0.12
Other   |            | 0.01069    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530638 ave      530638 max      530638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530638
Ave neighs/atom = 132.6595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.83264818979, Press = 0.770244799093401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13873.986     -13873.986     -14014.179     -14014.179      271.21204      271.21204      48087.813      48087.813     -898.87452     -898.87452    
     35000  -13876.864     -13876.864     -14016.866     -14016.866      270.84256      270.84256      48003.333      48003.333      1158.2477      1158.2477    
Loop time of 104.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.976 hours/ns, 9.586 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.16     | 104.16     | 104.16     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021893   | 0.021893   | 0.021893   |   0.0 |  0.02
Output  | 5.3741e-05 | 5.3741e-05 | 5.3741e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.12
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530210 ave      530210 max      530210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530210
Ave neighs/atom = 132.5525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.804729635941, Press = 0.727250809849824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13876.864     -13876.864     -14016.866     -14016.866      270.84256      270.84256      48003.333      48003.333      1158.2477      1158.2477    
     36000  -13872.719     -13872.719     -14012.786     -14012.786      270.96949      270.96949      48053.659      48053.659      227.44671      227.44671    
Loop time of 104.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.991 hours/ns, 9.581 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.21     | 104.21     | 104.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022177   | 0.022177   | 0.022177   |   0.0 |  0.02
Output  | 5.0064e-05 | 5.0064e-05 | 5.0064e-05 |   0.0 |  0.00
Modify  | 0.12339    | 0.12339    | 0.12339    |   0.0 |  0.12
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530732 ave      530732 max      530732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530732
Ave neighs/atom = 132.683
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.806087486581, Press = -1.03819428801566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13872.719     -13872.719     -14012.786     -14012.786      270.96949      270.96949      48053.659      48053.659      227.44671      227.44671    
     37000  -13879.639     -13879.639     -14015.838     -14015.838      263.48741      263.48741      48088.974      48088.974     -1152.2757     -1152.2757    
Loop time of 104.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.011 hours/ns, 9.575 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.28     | 104.28     | 104.28     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022002   | 0.022002   | 0.022002   |   0.0 |  0.02
Output  | 5.5374e-05 | 5.5374e-05 | 5.5374e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.12
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530244 ave      530244 max      530244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530244
Ave neighs/atom = 132.561
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.793997824387, Press = 0.683734148668751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13879.639     -13879.639     -14015.838     -14015.838      263.48741      263.48741      48088.974      48088.974     -1152.2757     -1152.2757    
     38000  -13872.616     -13872.616     -14016.497     -14016.497      278.34668      278.34668      48008.4        48008.4        1248.3618      1248.3618    
Loop time of 104.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.026 hours/ns, 9.570 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.34     | 104.34     | 104.34     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02187    | 0.02187    | 0.02187    |   0.0 |  0.02
Output  | 5.7649e-05 | 5.7649e-05 | 5.7649e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.12
Other   |            | 0.01049    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530650 ave      530650 max      530650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530650
Ave neighs/atom = 132.6625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.773335584981, Press = 1.32383337487988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13872.616     -13872.616     -14016.497     -14016.497      278.34668      278.34668      48008.4        48008.4        1248.3618      1248.3618    
     39000  -13876.343     -13876.343     -14016.312     -14016.312      270.78105      270.78105      48034.948      48034.948      416.29004      416.29004    
Loop time of 104.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.083 hours/ns, 9.551 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.54     | 104.54     | 104.54     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021867   | 0.021867   | 0.021867   |   0.0 |  0.02
Output  | 4.74e-05   | 4.74e-05   | 4.74e-05   |   0.0 |  0.00
Modify  | 0.12387    | 0.12387    | 0.12387    |   0.0 |  0.12
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       531082 ave      531082 max      531082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531082
Ave neighs/atom = 132.7705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.741986207078, Press = -0.593736844058965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13876.343     -13876.343     -14016.312     -14016.312      270.78105      270.78105      48034.948      48034.948      416.29004      416.29004    
     40000  -13877.02      -13877.02      -14012.727     -14012.727      262.53423      262.53423      48058.167      48058.167      4.7651409      4.7651409    
Loop time of 104.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.021 hours/ns, 9.572 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.32     | 104.32     | 104.32     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021746   | 0.021746   | 0.021746   |   0.0 |  0.02
Output  | 4.3482e-05 | 4.3482e-05 | 4.3482e-05 |   0.0 |  0.00
Modify  | 0.12339    | 0.12339    | 0.12339    |   0.0 |  0.12
Other   |            | 0.01047    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530876 ave      530876 max      530876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530876
Ave neighs/atom = 132.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.761260542089, Press = 0.580237540681497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13877.02      -13877.02      -14012.727     -14012.727      262.53423      262.53423      48058.167      48058.167      4.7651409      4.7651409    
     41000  -13872.238     -13872.238     -14015.032     -14015.032      276.24339      276.24339      48039.844      48039.844      410.7408       410.7408     
Loop time of 104.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.008 hours/ns, 9.576 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.27     | 104.27     | 104.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.02
Output  | 6.3649e-05 | 6.3649e-05 | 6.3649e-05 |   0.0 |  0.00
Modify  | 0.1234     | 0.1234     | 0.1234     |   0.0 |  0.12
Other   |            | 0.01044    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530278 ave      530278 max      530278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530278
Ave neighs/atom = 132.5695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.759365889399, Press = 0.243536379766099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13872.238     -13872.238     -14015.032     -14015.032      276.24339      276.24339      48039.844      48039.844      410.7408       410.7408     
     42000  -13874.852     -13874.852     -14016.785     -14016.785      274.57805      274.57805      48066.149      48066.149     -465.60035     -465.60035    
Loop time of 104.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.828 ns/day, 28.975 hours/ns, 9.587 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.16     | 104.16     | 104.16     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021657   | 0.021657   | 0.021657   |   0.0 |  0.02
Output  | 5.5164e-05 | 5.5164e-05 | 5.5164e-05 |   0.0 |  0.00
Modify  | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.12
Other   |            | 0.01115    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530550 ave      530550 max      530550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530550
Ave neighs/atom = 132.6375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.817173017946, Press = -0.188683932401074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13874.852     -13874.852     -14016.785     -14016.785      274.57805      274.57805      48066.149      48066.149     -465.60035     -465.60035    
     43000  -13869.267     -13869.267     -14012.486     -14012.486      277.0655       277.0655       48066.166      48066.166     -13.102213     -13.102213    
Loop time of 104.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.042 hours/ns, 9.565 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.4      | 104.4      | 104.4      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021603   | 0.021603   | 0.021603   |   0.0 |  0.02
Output  | 4.9934e-05 | 4.9934e-05 | 4.9934e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01073    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530678 ave      530678 max      530678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530678
Ave neighs/atom = 132.6695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.843128593354, Press = 0.530676236634747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13869.267     -13869.267     -14012.486     -14012.486      277.0655       277.0655       48066.166      48066.166     -13.102213     -13.102213    
     44000  -13874.912     -13874.912     -14014.603     -14014.603      270.24115      270.24115      48031.825      48031.825      613.58651      613.58651    
Loop time of 104.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.011 hours/ns, 9.575 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.28     | 104.28     | 104.28     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.02
Output  | 4.9814e-05 | 4.9814e-05 | 4.9814e-05 |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.12
Other   |            | 0.01045    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530024 ave      530024 max      530024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530024
Ave neighs/atom = 132.506
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84983691649, Press = -0.179031866450781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13874.912     -13874.912     -14014.603     -14014.603      270.24115      270.24115      48031.825      48031.825      613.58651      613.58651    
     45000  -13872.533     -13872.533     -14015.428     -14015.428      276.44079      276.44079      48085.138      48085.138     -875.65557     -875.65557    
Loop time of 103.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.831 ns/day, 28.870 hours/ns, 9.622 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.78     | 103.78     | 103.78     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.02
Output  | 4.7219e-05 | 4.7219e-05 | 4.7219e-05 |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.12
Other   |            | 0.011      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530238 ave      530238 max      530238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530238
Ave neighs/atom = 132.5595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.833598863132, Press = -0.307391625851498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13872.533     -13872.533     -14015.428     -14015.428      276.44079      276.44079      48085.138      48085.138     -875.65557     -875.65557    
     46000  -13874.37      -13874.37      -14013.925     -14013.925      269.97902      269.97902      48049.717      48049.717      138.02783      138.02783    
Loop time of 104.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.035 hours/ns, 9.567 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.37     | 104.37     | 104.37     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021803   | 0.021803   | 0.021803   |   0.0 |  0.02
Output  | 4.4394e-05 | 4.4394e-05 | 4.4394e-05 |   0.0 |  0.00
Modify  | 0.12383    | 0.12383    | 0.12383    |   0.0 |  0.12
Other   |            | 0.01069    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530326 ave      530326 max      530326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530326
Ave neighs/atom = 132.5815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824377598952, Press = 0.749701602931337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13874.37      -13874.37      -14013.925     -14013.925      269.97902      269.97902      48049.717      48049.717      138.02783      138.02783    
     47000  -13875.624     -13875.624     -14017.156     -14017.156      273.80235      273.80235      47997.948      47997.948      1425.2246      1425.2246    
Loop time of 104.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.830 ns/day, 28.902 hours/ns, 9.611 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.89     | 103.89     | 103.89     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0215     | 0.0215     | 0.0215     |   0.0 |  0.02
Output  | 5.7388e-05 | 5.7388e-05 | 5.7388e-05 |   0.0 |  0.00
Modify  | 0.12296    | 0.12296    | 0.12296    |   0.0 |  0.12
Other   |            | 0.01046    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530268 ave      530268 max      530268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530268
Ave neighs/atom = 132.567
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.84549459249, Press = -0.296153468982129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13875.624     -13875.624     -14017.156     -14017.156      273.80235      273.80235      47997.948      47997.948      1425.2246      1425.2246    
     48000  -13872.403     -13872.403     -14011.914     -14011.914      269.89271      269.89271      48110.342      48110.342     -1364.5001     -1364.5001    
Loop time of 103.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.831 ns/day, 28.887 hours/ns, 9.616 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.84     | 103.84     | 103.84     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02172    | 0.02172    | 0.02172    |   0.0 |  0.02
Output  | 4.8421e-05 | 4.8421e-05 | 4.8421e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.12
Other   |            | 0.01099    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530838 ave      530838 max      530838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530838
Ave neighs/atom = 132.7095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.869504470813, Press = -0.831087704175005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13872.403     -13872.403     -14011.914     -14011.914      269.89271      269.89271      48110.342      48110.342     -1364.5001     -1364.5001    
     49000  -13874.127     -13874.127     -14016.388     -14016.388      275.21407      275.21407      48049.668      48049.668     -10.655339     -10.655339    
Loop time of 104.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.027 hours/ns, 9.570 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.34     | 104.34     | 104.34     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021696   | 0.021696   | 0.021696   |   0.0 |  0.02
Output  | 6.9621e-05 | 6.9621e-05 | 6.9621e-05 |   0.0 |  0.00
Modify  | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.12
Other   |            | 0.01072    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5843 ave        5843 max        5843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529486 ave      529486 max      529486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529486
Ave neighs/atom = 132.3715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.877826184438, Press = 1.12156947355682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13874.127     -13874.127     -14016.388     -14016.388      275.21407      275.21407      48049.668      48049.668     -10.655339     -10.655339    
     50000  -13874.086     -13874.086     -14015.706     -14015.706      273.97381      273.97381      48035.45       48035.45       428.66605      428.66605    
Loop time of 104.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.106 hours/ns, 9.544 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.62     | 104.62     | 104.62     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02183    | 0.02183    | 0.02183    |   0.0 |  0.02
Output  | 5.5284e-05 | 5.5284e-05 | 5.5284e-05 |   0.0 |  0.00
Modify  | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.12
Other   |            | 0.01072    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530554 ave      530554 max      530554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530554
Ave neighs/atom = 132.6385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883637812181, Press = -0.237659468180156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13874.086     -13874.086     -14015.706     -14015.706      273.97381      273.97381      48035.45       48035.45       428.66605      428.66605    
     51000  -13872.95      -13872.95      -14015.444     -14015.444      275.66343      275.66343      48070.689      48070.689     -501.10421     -501.10421    
Loop time of 104.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.137 hours/ns, 9.533 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.74     | 104.74     | 104.74     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021777   | 0.021777   | 0.021777   |   0.0 |  0.02
Output  | 5.8139e-05 | 5.8139e-05 | 5.8139e-05 |   0.0 |  0.00
Modify  | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.12
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5842 ave        5842 max        5842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530850 ave      530850 max      530850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530850
Ave neighs/atom = 132.7125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.876210402548, Press = 0.0640370972910769
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13872.95      -13872.95      -14015.444     -14015.444      275.66343      275.66343      48070.689      48070.689     -501.10421     -501.10421    
     52000  -13874.111     -13874.111     -14014.388     -14014.388      271.37527      271.37527      48037.088      48037.088      495.08134      495.08134    
Loop time of 105.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.406 hours/ns, 9.446 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.7      | 105.7      | 105.7      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022166   | 0.022166   | 0.022166   |   0.0 |  0.02
Output  | 0.0001392  | 0.0001392  | 0.0001392  |   0.0 |  0.00
Modify  | 0.12588    | 0.12588    | 0.12588    |   0.0 |  0.12
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530178 ave      530178 max      530178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530178
Ave neighs/atom = 132.5445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.872193021794, Press = 0.0944444767420039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13874.111     -13874.111     -14014.388     -14014.388      271.37527      271.37527      48037.088      48037.088      495.08134      495.08134    
     53000  -13872.264     -13872.264     -14015.297     -14015.297      276.7065       276.7065       48071.872      48071.872     -526.73971     -526.73971    
Loop time of 105.569 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.325 hours/ns, 9.472 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.41     | 105.41     | 105.41     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021806   | 0.021806   | 0.021806   |   0.0 |  0.02
Output  | 5.836e-05  | 5.836e-05  | 5.836e-05  |   0.0 |  0.00
Modify  | 0.12474    | 0.12474    | 0.12474    |   0.0 |  0.12
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530744 ave      530744 max      530744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530744
Ave neighs/atom = 132.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883507643952, Press = -0.589647932394231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13872.264     -13872.264     -14015.297     -14015.297      276.7065       276.7065       48071.872      48071.872     -526.73971     -526.73971    
     54000  -13876.996     -13876.996     -14015.335     -14015.335      267.62574      267.62574      48062.612      48062.612     -337.36162     -337.36162    
Loop time of 105.19 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.821 ns/day, 29.219 hours/ns, 9.507 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.03     | 105.03     | 105.03     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021843   | 0.021843   | 0.021843   |   0.0 |  0.02
Output  | 5.4973e-05 | 5.4973e-05 | 5.4973e-05 |   0.0 |  0.00
Modify  | 0.12477    | 0.12477    | 0.12477    |   0.0 |  0.12
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530538 ave      530538 max      530538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530538
Ave neighs/atom = 132.6345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.849925992953, Press = 0.82474332039371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13876.996     -13876.996     -14015.335     -14015.335      267.62574      267.62574      48062.612      48062.612     -337.36162     -337.36162    
     55000  -13873.735     -13873.735     -14014.392     -14014.392      272.11116      272.11116      47996.431      47996.431      1582.9047      1582.9047    
Loop time of 105.436 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.819 ns/day, 29.288 hours/ns, 9.484 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.28     | 105.28     | 105.28     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021822   | 0.021822   | 0.021822   |   0.0 |  0.02
Output  | 5.5133e-05 | 5.5133e-05 | 5.5133e-05 |   0.0 |  0.00
Modify  | 0.12445    | 0.12445    | 0.12445    |   0.0 |  0.12
Other   |            | 0.01071    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530290 ave      530290 max      530290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530290
Ave neighs/atom = 132.5725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.835748793068, Press = 0.117124687153804
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13873.735     -13873.735     -14014.392     -14014.392      272.11116      272.11116      47996.431      47996.431      1582.9047      1582.9047    
     56000  -13871.52      -13871.52      -14013.246     -14013.246      274.17799      274.17799      48067.969      48067.969     -276.97717     -276.97717    
Loop time of 105.407 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.820 ns/day, 29.280 hours/ns, 9.487 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.25     | 105.25     | 105.25     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.02
Output  | 4.799e-05  | 4.799e-05  | 4.799e-05  |   0.0 |  0.00
Modify  | 0.12455    | 0.12455    | 0.12455    |   0.0 |  0.12
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530666 ave      530666 max      530666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530666
Ave neighs/atom = 132.6665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.815679825908, Press = -0.772703175557619
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13871.52      -13871.52      -14013.246     -14013.246      274.17799      274.17799      48067.969      48067.969     -276.97717     -276.97717    
     57000  -13873.963     -13873.963     -14016.972     -14016.972      276.66043      276.66043      48093.898      48093.898     -1352.3724     -1352.3724    
Loop time of 104.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.078 hours/ns, 9.553 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.52     | 104.52     | 104.52     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021813   | 0.021813   | 0.021813   |   0.0 |  0.02
Output  | 5.7378e-05 | 5.7378e-05 | 5.7378e-05 |   0.0 |  0.00
Modify  | 0.12378    | 0.12378    | 0.12378    |   0.0 |  0.12
Other   |            | 0.01078    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       529780 ave      529780 max      529780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 529780
Ave neighs/atom = 132.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857564061619, Press = 0.321695594543748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13873.963     -13873.963     -14016.972     -14016.972      276.66043      276.66043      48093.898      48093.898     -1352.3724     -1352.3724    
     58000  -13871.001     -13871.001     -14013.4       -14013.4        275.47931      275.47931      48002.423      48002.423      1568.7851      1568.7851    
Loop time of 104.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.061 hours/ns, 9.559 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.46     | 104.46     | 104.46     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021686   | 0.021686   | 0.021686   |   0.0 |  0.02
Output  | 5.5605e-05 | 5.5605e-05 | 5.5605e-05 |   0.0 |  0.00
Modify  | 0.12402    | 0.12402    | 0.12402    |   0.0 |  0.12
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530446 ave      530446 max      530446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530446
Ave neighs/atom = 132.6115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883106541501, Press = 0.12447768926741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13871.001     -13871.001     -14013.4       -14013.4        275.47931      275.47931      48002.423      48002.423      1568.7851      1568.7851    
     59000  -13874.818     -13874.818     -14015.92      -14015.92       272.97086      272.97086      48086.025      48086.025     -1049.8349     -1049.8349    
Loop time of 104.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.078 hours/ns, 9.553 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.52     | 104.52     | 104.52     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021647   | 0.021647   | 0.021647   |   0.0 |  0.02
Output  | 5.8951e-05 | 5.8951e-05 | 5.8951e-05 |   0.0 |  0.00
Modify  | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.12
Other   |            | 0.01061    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530452 ave      530452 max      530452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530452
Ave neighs/atom = 132.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 = 272.885383235949, Press = -0.647580418961207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13874.818     -13874.818     -14015.92      -14015.92       272.97086      272.97086      48086.025      48086.025     -1049.8349     -1049.8349    
     60000  -13870.43      -13870.43      -14014.534     -14014.534      278.77913      278.77913      48073.308      48073.308     -414.60251     -414.60251    
Loop time of 104.555 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.826 ns/day, 29.043 hours/ns, 9.564 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.4      | 104.4      | 104.4      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021667   | 0.021667   | 0.021667   |   0.0 |  0.02
Output  | 5.8761e-05 | 5.8761e-05 | 5.8761e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.12
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530166 ave      530166 max      530166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530166
Ave neighs/atom = 132.5415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.923202389311, Press = 0.391526916191994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13870.43      -13870.43      -14014.534     -14014.534      278.77913      278.77913      48073.308      48073.308     -414.60251     -414.60251    
     61000  -13874.346     -13874.346     -14016.713     -14016.713      275.41899      275.41899      48033.214      48033.214      452.3432       452.3432     
Loop time of 104.793 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.824 ns/day, 29.109 hours/ns, 9.543 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.64     | 104.64     | 104.64     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021762   | 0.021762   | 0.021762   |   0.0 |  0.02
Output  | 6.6485e-05 | 6.6485e-05 | 6.6485e-05 |   0.0 |  0.00
Modify  | 0.12417    | 0.12417    | 0.12417    |   0.0 |  0.12
Other   |            | 0.01065    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530270 ave      530270 max      530270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530270
Ave neighs/atom = 132.5675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.941350688831, Press = 0.0557983937077633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13874.346     -13874.346     -14016.713     -14016.713      275.41899      275.41899      48033.214      48033.214      452.3432       452.3432     
     62000  -13873.875     -13873.875     -14014.861     -14014.861      272.74828      272.74828      48059.042      48059.042     -94.745806     -94.745806    
Loop time of 104.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.825 ns/day, 29.078 hours/ns, 9.553 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021548   | 0.021548   | 0.021548   |   0.0 |  0.02
Output  | 6.6385e-05 | 6.6385e-05 | 6.6385e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       530692 ave      530692 max      530692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530692
Ave neighs/atom = 132.673
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
48051.4378634982

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0