# 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.5090000331401834*${_u_distance}
variable latticeconst_converted equal 3.5090000331401834*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.50900003314018
Lattice spacing in x,y,z = 3.509 3.509 3.509
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.09 35.09 35.09)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.09 35.09 35.09)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_001
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43206.6024531732 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_971738391444_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3229.4205     -3229.4205     -3300          -3300           273.15         273.15         43206.602      43206.602      1744.8045      1744.8045    
      1000  -3213.0206     -3213.0206     -3282.9603     -3282.9603      270.67355      270.67355      47079.923      47079.923      268.72302      268.72302    
Loop time of 17.2882 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.998 ns/day, 4.802 hours/ns, 57.843 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.094     | 17.094     | 17.094     |   0.0 | 98.88
Neigh   | 0.11554    | 0.11554    | 0.11554    |   0.0 |  0.67
Comm    | 0.013374   | 0.013374   | 0.013374   |   0.0 |  0.08
Output  | 0.00011715 | 0.00011715 | 0.00011715 |   0.0 |  0.00
Modify  | 0.060654   | 0.060654   | 0.060654   |   0.0 |  0.35
Other   |            | 0.004762   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3241 ave        3241 max        3241 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119714 ave      119714 max      119714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119714
Ave neighs/atom = 59.857
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3213.0206     -3213.0206     -3282.9603     -3282.9603      270.67355      270.67355      47079.923      47079.923      268.72302      268.72302    
      2000  -3212.6159     -3212.6159     -3283.6421     -3283.6421      274.87882      274.87882      47174.684      47174.684      54.368942      54.368942    
Loop time of 17.1922 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.026 ns/day, 4.776 hours/ns, 58.166 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    | 17.006     | 17.006     | 17.006     |   0.0 | 98.92
Neigh   | 0.10822    | 0.10822    | 0.10822    |   0.0 |  0.63
Comm    | 0.013425   | 0.013425   | 0.013425   |   0.0 |  0.08
Output  | 3.7631e-05 | 3.7631e-05 | 3.7631e-05 |   0.0 |  0.00
Modify  | 0.059578   | 0.059578   | 0.059578   |   0.0 |  0.35
Other   |            | 0.004591   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3277 ave        3277 max        3277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119640 ave      119640 max      119640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119640
Ave neighs/atom = 59.82
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3212.6159     -3212.6159     -3283.6421     -3283.6421      274.87882      274.87882      47174.684      47174.684      54.368942      54.368942    
      3000  -3211.7289     -3211.7289     -3281.5217     -3281.5217      270.10531      270.10531      47207.389      47207.389      81.705956      81.705956    
Loop time of 17.1436 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.040 ns/day, 4.762 hours/ns, 58.331 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    | 16.959     | 16.959     | 16.959     |   0.0 | 98.92
Neigh   | 0.10719    | 0.10719    | 0.10719    |   0.0 |  0.63
Comm    | 0.013429   | 0.013429   | 0.013429   |   0.0 |  0.08
Output  | 5.2519e-05 | 5.2519e-05 | 5.2519e-05 |   0.0 |  0.00
Modify  | 0.059449   | 0.059449   | 0.059449   |   0.0 |  0.35
Other   |            | 0.004615   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119606 ave      119606 max      119606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119606
Ave neighs/atom = 59.803
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3211.7289     -3211.7289     -3281.5217     -3281.5217      270.10531      270.10531      47207.389      47207.389      81.705956      81.705956    
      4000  -3211.1457     -3211.1457     -3281.7909     -3281.7909      273.40445      273.40445      47200.674      47200.674     -49.841195     -49.841195    
Loop time of 17.1937 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.025 ns/day, 4.776 hours/ns, 58.161 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    | 17.01      | 17.01      | 17.01      |   0.0 | 98.93
Neigh   | 0.10633    | 0.10633    | 0.10633    |   0.0 |  0.62
Comm    | 0.0134     | 0.0134     | 0.0134     |   0.0 |  0.08
Output  | 3.6779e-05 | 3.6779e-05 | 3.6779e-05 |   0.0 |  0.00
Modify  | 0.059331   | 0.059331   | 0.059331   |   0.0 |  0.35
Other   |            | 0.004618   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3289 ave        3289 max        3289 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119534 ave      119534 max      119534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119534
Ave neighs/atom = 59.767
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3211.1457     -3211.1457     -3281.7909     -3281.7909      273.40445      273.40445      47200.674      47200.674     -49.841195     -49.841195    
      5000  -3213.5756     -3213.5756     -3283.677      -3283.677       271.29987      271.29987      47148.553      47148.553      144.25412      144.25412    
Loop time of 17.1957 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.025 ns/day, 4.777 hours/ns, 58.154 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    | 17.007     | 17.007     | 17.007     |   0.0 | 98.90
Neigh   | 0.11109    | 0.11109    | 0.11109    |   0.0 |  0.65
Comm    | 0.013413   | 0.013413   | 0.013413   |   0.0 |  0.08
Output  | 2.2322e-05 | 2.2322e-05 | 2.2322e-05 |   0.0 |  0.00
Modify  | 0.0596     | 0.0596     | 0.0596     |   0.0 |  0.35
Other   |            | 0.004531   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119678 ave      119678 max      119678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119678
Ave neighs/atom = 59.839
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 267.343969258355, Press = 232.146531234732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3213.5756     -3213.5756     -3283.677      -3283.677       271.29987      271.29987      47148.553      47148.553      144.25412      144.25412    
      6000  -3210.9226     -3210.9226     -3282.5653     -3282.5653      277.26447      277.26447      47341.309      47341.309     -197.30369     -197.30369    
Loop time of 17.1521 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.037 ns/day, 4.764 hours/ns, 58.302 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.961     | 16.961     | 16.961     |   0.0 | 98.88
Neigh   | 0.11174    | 0.11174    | 0.11174    |   0.0 |  0.65
Comm    | 0.013448   | 0.013448   | 0.013448   |   0.0 |  0.08
Output  | 3.9915e-05 | 3.9915e-05 | 3.9915e-05 |   0.0 |  0.00
Modify  | 0.061701   | 0.061701   | 0.061701   |   0.0 |  0.36
Other   |            | 0.004528   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3271 ave        3271 max        3271 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119324 ave      119324 max      119324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119324
Ave neighs/atom = 59.662
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.824935035304, Press = 27.1785049906569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3210.9226     -3210.9226     -3282.5653     -3282.5653      277.26447      277.26447      47341.309      47341.309     -197.30369     -197.30369    
      7000  -3214.3996     -3214.3996     -3284.0054     -3284.0054      269.38185      269.38185      47349.344      47349.344     -408.16004     -408.16004    
Loop time of 17.1544 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.037 ns/day, 4.765 hours/ns, 58.294 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.964     | 16.964     | 16.964     |   0.0 | 98.89
Neigh   | 0.11086    | 0.11086    | 0.11086    |   0.0 |  0.65
Comm    | 0.013348   | 0.013348   | 0.013348   |   0.0 |  0.08
Output  | 3.2461e-05 | 3.2461e-05 | 3.2461e-05 |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.36
Other   |            | 0.004581   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3266 ave        3266 max        3266 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119458 ave      119458 max      119458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119458
Ave neighs/atom = 59.729
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.131831139859, Press = 10.9232776317635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3214.3996     -3214.3996     -3284.0054     -3284.0054      269.38185      269.38185      47349.344      47349.344     -408.16004     -408.16004    
      8000  -3215.5775     -3215.5775     -3286.5504     -3286.5504      274.67225      274.67225      47352.293      47352.293     -243.05811     -243.05811    
Loop time of 17.1554 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.036 ns/day, 4.765 hours/ns, 58.291 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    | 16.967     | 16.967     | 16.967     |   0.0 | 98.90
Neigh   | 0.10929    | 0.10929    | 0.10929    |   0.0 |  0.64
Comm    | 0.013218   | 0.013218   | 0.013218   |   0.0 |  0.08
Output  | 2.3815e-05 | 2.3815e-05 | 2.3815e-05 |   0.0 |  0.00
Modify  | 0.06161    | 0.06161    | 0.06161    |   0.0 |  0.36
Other   |            | 0.004574   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3307 ave        3307 max        3307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119176 ave      119176 max      119176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119176
Ave neighs/atom = 59.588
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.560629245556, Press = -9.64512902064405
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3215.5775     -3215.5775     -3286.5504     -3286.5504      274.67225      274.67225      47352.293      47352.293     -243.05811     -243.05811    
      9000  -3213.961      -3213.961      -3285.8227     -3285.8227      278.11205      278.11205      46973.088      46973.088      562.38295      562.38295    
Loop time of 17.1263 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.045 ns/day, 4.757 hours/ns, 58.390 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    | 16.938     | 16.938     | 16.938     |   0.0 | 98.90
Neigh   | 0.10886    | 0.10886    | 0.10886    |   0.0 |  0.64
Comm    | 0.013313   | 0.013313   | 0.013313   |   0.0 |  0.08
Output  | 3.0778e-05 | 3.0778e-05 | 3.0778e-05 |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.36
Other   |            | 0.004641   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3292 ave        3292 max        3292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119850 ave      119850 max      119850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119850
Ave neighs/atom = 59.925
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.057724592856, Press = 2.81594071465619
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3213.961      -3213.961      -3285.8227     -3285.8227      278.11205      278.11205      46973.088      46973.088      562.38295      562.38295    
     10000  -3214.0915     -3214.0915     -3284.1985     -3284.1985      271.32141      271.32141      47159.823      47159.823      97.828927      97.828927    
Loop time of 17.1147 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.048 ns/day, 4.754 hours/ns, 58.429 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    | 16.931     | 16.931     | 16.931     |   0.0 | 98.93
Neigh   | 0.10415    | 0.10415    | 0.10415    |   0.0 |  0.61
Comm    | 0.013249   | 0.013249   | 0.013249   |   0.0 |  0.08
Output  | 2.2192e-05 | 2.2192e-05 | 2.2192e-05 |   0.0 |  0.00
Modify  | 0.061442   | 0.061442   | 0.061442   |   0.0 |  0.36
Other   |            | 0.004535   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3338 ave        3338 max        3338 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119894 ave      119894 max      119894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119894
Ave neighs/atom = 59.947
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399563025912, Press = 6.00701907371161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3214.0915     -3214.0915     -3284.1985     -3284.1985      271.32141      271.32141      47159.823      47159.823      97.828927      97.828927    
     11000  -3215.052      -3215.052      -3285.9473     -3285.9473      274.37235      274.37235      47276.735      47276.735     -68.988203     -68.988203    
Loop time of 17.1822 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.028 ns/day, 4.773 hours/ns, 58.200 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    | 16.992     | 16.992     | 16.992     |   0.0 | 98.90
Neigh   | 0.1103     | 0.1103     | 0.1103     |   0.0 |  0.64
Comm    | 0.013416   | 0.013416   | 0.013416   |   0.0 |  0.08
Output  | 2.5889e-05 | 2.5889e-05 | 2.5889e-05 |   0.0 |  0.00
Modify  | 0.061535   | 0.061535   | 0.061535   |   0.0 |  0.36
Other   |            | 0.004547   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3280 ave        3280 max        3280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119454 ave      119454 max      119454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119454
Ave neighs/atom = 59.727
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.323465192292, Press = 1.78283866891135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3215.052      -3215.052      -3285.9473     -3285.9473      274.37235      274.37235      47276.735      47276.735     -68.988203     -68.988203    
     12000  -3212.2006     -3212.2006     -3285.2086     -3285.2086      282.54849      282.54849      47195.467      47195.467      101.65593      101.65593    
Loop time of 17.2609 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.006 ns/day, 4.795 hours/ns, 57.935 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.071     | 17.071     | 17.071     |   0.0 | 98.90
Neigh   | 0.11005    | 0.11005    | 0.11005    |   0.0 |  0.64
Comm    | 0.013424   | 0.013424   | 0.013424   |   0.0 |  0.08
Output  | 3.1178e-05 | 3.1178e-05 | 3.1178e-05 |   0.0 |  0.00
Modify  | 0.061581   | 0.061581   | 0.061581   |   0.0 |  0.36
Other   |            | 0.004573   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3329 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119840 ave      119840 max      119840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119840
Ave neighs/atom = 59.92
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.316198027763, Press = 1.40384099665
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3212.2006     -3212.2006     -3285.2086     -3285.2086      282.54849      282.54849      47195.467      47195.467      101.65593      101.65593    
     13000  -3217.34       -3217.34       -3289.1313     -3289.1313      277.83971      277.83971      47213.799      47213.799      141.56209      141.56209    
Loop time of 17.2488 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.009 ns/day, 4.791 hours/ns, 57.975 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    | 17.06      | 17.06      | 17.06      |   0.0 | 98.91
Neigh   | 0.10914    | 0.10914    | 0.10914    |   0.0 |  0.63
Comm    | 0.013373   | 0.013373   | 0.013373   |   0.0 |  0.08
Output  | 2.2352e-05 | 2.2352e-05 | 2.2352e-05 |   0.0 |  0.00
Modify  | 0.061661   | 0.061661   | 0.061661   |   0.0 |  0.36
Other   |            | 0.004575   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3315 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119468 ave      119468 max      119468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119468
Ave neighs/atom = 59.734
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.63899051544, Press = 2.72373256208746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3217.34       -3217.34       -3289.1313     -3289.1313      277.83971      277.83971      47213.799      47213.799      141.56209      141.56209    
     14000  -3216.281      -3216.281      -3288.0717     -3288.0717      277.83769      277.83769      47294.745      47294.745     -70.129711     -70.129711    
Loop time of 17.3566 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.978 ns/day, 4.821 hours/ns, 57.615 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.168     | 17.168     | 17.168     |   0.0 | 98.91
Neigh   | 0.10923    | 0.10923    | 0.10923    |   0.0 |  0.63
Comm    | 0.013373   | 0.013373   | 0.013373   |   0.0 |  0.08
Output  | 9.1692e-05 | 9.1692e-05 | 9.1692e-05 |   0.0 |  0.00
Modify  | 0.061606   | 0.061606   | 0.061606   |   0.0 |  0.35
Other   |            | 0.004627   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119152 ave      119152 max      119152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119152
Ave neighs/atom = 59.576
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941246598636, Press = 1.10927910404588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3216.281      -3216.281      -3288.0717     -3288.0717      277.83769      277.83769      47294.745      47294.745     -70.129711     -70.129711    
     15000  -3214.7377     -3214.7377     -3285.7768     -3285.7768      274.92845      274.92845      47432.57       47432.57      -357.47447     -357.47447    
Loop time of 17.2974 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.995 ns/day, 4.805 hours/ns, 57.812 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    | 17.109     | 17.109     | 17.109     |   0.0 | 98.91
Neigh   | 0.10843    | 0.10843    | 0.10843    |   0.0 |  0.63
Comm    | 0.013399   | 0.013399   | 0.013399   |   0.0 |  0.08
Output  | 2.8504e-05 | 2.8504e-05 | 2.8504e-05 |   0.0 |  0.00
Modify  | 0.061616   | 0.061616   | 0.061616   |   0.0 |  0.36
Other   |            | 0.004606   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3308 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119290 ave      119290 max      119290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119290
Ave neighs/atom = 59.645
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.775146471988, Press = -2.00079115217981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3214.7377     -3214.7377     -3285.7768     -3285.7768      274.92845      274.92845      47432.57       47432.57      -357.47447     -357.47447    
     16000  -3218.1894     -3218.1894     -3288.7098     -3288.7098      272.92151      272.92151      46903.176      46903.176      857.69754      857.69754    
Loop time of 17.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.984 ns/day, 4.816 hours/ns, 57.680 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    | 17.149     | 17.149     | 17.149     |   0.0 | 98.91
Neigh   | 0.10852    | 0.10852    | 0.10852    |   0.0 |  0.63
Comm    | 0.013401   | 0.013401   | 0.013401   |   0.0 |  0.08
Output  | 2.2382e-05 | 2.2382e-05 | 2.2382e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.36
Other   |            | 0.004544   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3331 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       120022 ave      120022 max      120022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120022
Ave neighs/atom = 60.011
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.612299035761, Press = -1.42722156995233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3218.1894     -3218.1894     -3288.7098     -3288.7098      272.92151      272.92151      46903.176      46903.176      857.69754      857.69754    
     17000  -3219.0483     -3219.0483     -3287.338      -3287.338       264.28818      264.28818      47127.82       47127.82       170.85603      170.85603    
Loop time of 17.3777 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.972 ns/day, 4.827 hours/ns, 57.545 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    | 17.195     | 17.195     | 17.195     |   0.0 | 98.95
Neigh   | 0.10356    | 0.10356    | 0.10356    |   0.0 |  0.60
Comm    | 0.013394   | 0.013394   | 0.013394   |   0.0 |  0.08
Output  | 2.2913e-05 | 2.2913e-05 | 2.2913e-05 |   0.0 |  0.00
Modify  | 0.061619   | 0.061619   | 0.061619   |   0.0 |  0.35
Other   |            | 0.004564   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3338 ave        3338 max        3338 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119790 ave      119790 max      119790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119790
Ave neighs/atom = 59.895
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.58578016508, Press = 2.75258062991291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3219.0483     -3219.0483     -3287.338      -3287.338       264.28818      264.28818      47127.82       47127.82       170.85603      170.85603    
     18000  -3216.9638     -3216.9638     -3287.9512     -3287.9512      274.72873      274.72873      47436.542      47436.542     -329.67287     -329.67287    
Loop time of 17.3191 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.989 ns/day, 4.811 hours/ns, 57.740 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    | 17.131     | 17.131     | 17.131     |   0.0 | 98.91
Neigh   | 0.10874    | 0.10874    | 0.10874    |   0.0 |  0.63
Comm    | 0.013354   | 0.013354   | 0.013354   |   0.0 |  0.08
Output  | 2.2512e-05 | 2.2512e-05 | 2.2512e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.36
Other   |            | 0.004553   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3356 ave        3356 max        3356 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119102 ave      119102 max      119102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119102
Ave neighs/atom = 59.551
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.582921679041, Press = 1.79975940462095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3216.9638     -3216.9638     -3287.9512     -3287.9512      274.72873      274.72873      47436.542      47436.542     -329.67287     -329.67287    
     19000  -3217.2411     -3217.2411     -3287.897      -3287.897       273.44546      273.44546      47313.719      47313.719     -192.99305     -192.99305    
Loop time of 17.3321 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.985 ns/day, 4.814 hours/ns, 57.696 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    | 17.144     | 17.144     | 17.144     |   0.0 | 98.92
Neigh   | 0.10847    | 0.10847    | 0.10847    |   0.0 |  0.63
Comm    | 0.013345   | 0.013345   | 0.013345   |   0.0 |  0.08
Output  | 3.0657e-05 | 3.0657e-05 | 3.0657e-05 |   0.0 |  0.00
Modify  | 0.061476   | 0.061476   | 0.061476   |   0.0 |  0.35
Other   |            | 0.004564   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3330 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119334 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.454723999999, Press = 1.25513697437954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3217.2411     -3217.2411     -3287.897      -3287.897       273.44546      273.44546      47313.719      47313.719     -192.99305     -192.99305    
     20000  -3218.2572     -3218.2572     -3287.1953     -3287.1953      266.79723      266.79723      47129.125      47129.125      258.60814      258.60814    
Loop time of 17.2905 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.997 ns/day, 4.803 hours/ns, 57.835 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    | 17.107     | 17.107     | 17.107     |   0.0 | 98.94
Neigh   | 0.10374    | 0.10374    | 0.10374    |   0.0 |  0.60
Comm    | 0.013308   | 0.013308   | 0.013308   |   0.0 |  0.08
Output  | 2.2573e-05 | 2.2573e-05 | 2.2573e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.36
Other   |            | 0.004581   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119506 ave      119506 max      119506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119506
Ave neighs/atom = 59.753
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.528678621693, Press = -1.11834511117151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3218.2572     -3218.2572     -3287.1953     -3287.1953      266.79723      266.79723      47129.125      47129.125      258.60814      258.60814    
     21000  -3217.1207     -3217.1207     -3286.1683     -3286.1683      267.22113      267.22113      47144.889      47144.889      198.19338      198.19338    
Loop time of 17.3421 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.982 ns/day, 4.817 hours/ns, 57.663 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    | 17.16      | 17.16      | 17.16      |   0.0 | 98.95
Neigh   | 0.10302    | 0.10302    | 0.10302    |   0.0 |  0.59
Comm    | 0.013341   | 0.013341   | 0.013341   |   0.0 |  0.08
Output  | 2.3013e-05 | 2.3013e-05 | 2.3013e-05 |   0.0 |  0.00
Modify  | 0.061528   | 0.061528   | 0.061528   |   0.0 |  0.35
Other   |            | 0.004566   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3320 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119606 ave      119606 max      119606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119606
Ave neighs/atom = 59.803
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.552906290757, Press = 2.45371606876736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3217.1207     -3217.1207     -3286.1683     -3286.1683      267.22113      267.22113      47144.889      47144.889      198.19338      198.19338    
     22000  -3218.5834     -3218.5834     -3288.6858     -3288.6858      271.30365      271.30365      47357.103      47357.103     -277.35392     -277.35392    
Loop time of 17.3437 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.982 ns/day, 4.818 hours/ns, 57.658 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    | 17.16      | 17.16      | 17.16      |   0.0 | 98.94
Neigh   | 0.1038     | 0.1038     | 0.1038     |   0.0 |  0.60
Comm    | 0.013308   | 0.013308   | 0.013308   |   0.0 |  0.08
Output  | 2.8473e-05 | 2.8473e-05 | 2.8473e-05 |   0.0 |  0.00
Modify  | 0.061612   | 0.061612   | 0.061612   |   0.0 |  0.36
Other   |            | 0.004564   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3354 ave        3354 max        3354 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119356 ave      119356 max      119356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119356
Ave neighs/atom = 59.678
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.592784668806, Press = 0.426672478421753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3218.5834     -3218.5834     -3288.6858     -3288.6858      271.30365      271.30365      47357.103      47357.103     -277.35392     -277.35392    
     23000  -3215.9731     -3215.9731     -3287.1299     -3287.1299      275.38403      275.38403      47234.428      47234.428      158.08133      158.08133    
Loop time of 17.3627 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.976 ns/day, 4.823 hours/ns, 57.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    | 17.175     | 17.175     | 17.175     |   0.0 | 98.92
Neigh   | 0.1084     | 0.1084     | 0.1084     |   0.0 |  0.62
Comm    | 0.013349   | 0.013349   | 0.013349   |   0.0 |  0.08
Output  | 2.1501e-05 | 2.1501e-05 | 2.1501e-05 |   0.0 |  0.00
Modify  | 0.061599   | 0.061599   | 0.061599   |   0.0 |  0.35
Other   |            | 0.004548   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3321 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119614 ave      119614 max      119614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119614
Ave neighs/atom = 59.807
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.64469868917, Press = -0.305078688221381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3215.9731     -3215.9731     -3287.1299     -3287.1299      275.38403      275.38403      47234.428      47234.428      158.08133      158.08133    
     24000  -3214.1876     -3214.1876     -3287.0837     -3287.0837      282.1155       282.1155       47170.336      47170.336      188.51772      188.51772    
Loop time of 17.3861 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.969 ns/day, 4.829 hours/ns, 57.517 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    | 17.198     | 17.198     | 17.198     |   0.0 | 98.92
Neigh   | 0.10833    | 0.10833    | 0.10833    |   0.0 |  0.62
Comm    | 0.013401   | 0.013401   | 0.013401   |   0.0 |  0.08
Output  | 2.2001e-05 | 2.2001e-05 | 2.2001e-05 |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.35
Other   |            | 0.004564   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3326 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119704 ave      119704 max      119704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119704
Ave neighs/atom = 59.852
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.733736404328, Press = 1.73435042012427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3214.1876     -3214.1876     -3287.0837     -3287.0837      282.1155       282.1155       47170.336      47170.336      188.51772      188.51772    
     25000  -3217.5083     -3217.5083     -3287.8352     -3287.8352      272.17247      272.17247      47338.257      47338.257     -189.69947     -189.69947    
Loop time of 17.3535 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.979 ns/day, 4.820 hours/ns, 57.625 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    | 17.166     | 17.166     | 17.166     |   0.0 | 98.92
Neigh   | 0.10841    | 0.10841    | 0.10841    |   0.0 |  0.62
Comm    | 0.013378   | 0.013378   | 0.013378   |   0.0 |  0.08
Output  | 2.2402e-05 | 2.2402e-05 | 2.2402e-05 |   0.0 |  0.00
Modify  | 0.061592   | 0.061592   | 0.061592   |   0.0 |  0.35
Other   |            | 0.004565   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3340 ave        3340 max        3340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119228 ave      119228 max      119228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119228
Ave neighs/atom = 59.614
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.881760112867, Press = 0.830845155773855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3217.5083     -3217.5083     -3287.8352     -3287.8352      272.17247      272.17247      47338.257      47338.257     -189.69947     -189.69947    
     26000  -3217.9418     -3217.9418     -3289.3155     -3289.3155      276.22343      276.22343      47406.762      47406.762     -379.45953     -379.45953    
Loop time of 17.3594 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.977 ns/day, 4.822 hours/ns, 57.606 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    | 17.172     | 17.172     | 17.172     |   0.0 | 98.92
Neigh   | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.62
Comm    | 0.013409   | 0.013409   | 0.013409   |   0.0 |  0.08
Output  | 3.0758e-05 | 3.0758e-05 | 3.0758e-05 |   0.0 |  0.00
Modify  | 0.061565   | 0.061565   | 0.061565   |   0.0 |  0.35
Other   |            | 0.004562   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119386 ave      119386 max      119386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119386
Ave neighs/atom = 59.693
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9249451082, Press = -0.909722239321575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3217.9418     -3217.9418     -3289.3155     -3289.3155      276.22343      276.22343      47406.762      47406.762     -379.45953     -379.45953    
     27000  -3220.2693     -3220.2693     -3289.8614     -3289.8614      269.3285       269.3285       46981.822      46981.822      593.7453       593.7453     
Loop time of 17.3835 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.970 ns/day, 4.829 hours/ns, 57.526 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    | 17.196     | 17.196     | 17.196     |   0.0 | 98.92
Neigh   | 0.10813    | 0.10813    | 0.10813    |   0.0 |  0.62
Comm    | 0.013371   | 0.013371   | 0.013371   |   0.0 |  0.08
Output  | 2.2893e-05 | 2.2893e-05 | 2.2893e-05 |   0.0 |  0.00
Modify  | 0.061546   | 0.061546   | 0.061546   |   0.0 |  0.35
Other   |            | 0.004552   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3371 ave        3371 max        3371 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119672 ave      119672 max      119672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119672
Ave neighs/atom = 59.836
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.914693601842, Press = -0.476489500447734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3220.2693     -3220.2693     -3289.8614     -3289.8614      269.3285       269.3285       46981.822      46981.822      593.7453       593.7453     
     28000  -3216.7007     -3216.7007     -3287.7378     -3287.7378      274.92077      274.92077      47183.26       47183.26       244.20925      244.20925    
Loop time of 17.4039 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.964 ns/day, 4.834 hours/ns, 57.458 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    | 17.216     | 17.216     | 17.216     |   0.0 | 98.92
Neigh   | 0.1082     | 0.1082     | 0.1082     |   0.0 |  0.62
Comm    | 0.013364   | 0.013364   | 0.013364   |   0.0 |  0.08
Output  | 2.2402e-05 | 2.2402e-05 | 2.2402e-05 |   0.0 |  0.00
Modify  | 0.061612   | 0.061612   | 0.061612   |   0.0 |  0.35
Other   |            | 0.004569   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3313 ave        3313 max        3313 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119552 ave      119552 max      119552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119552
Ave neighs/atom = 59.776
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858262571612, Press = 1.96046954008019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3216.7007     -3216.7007     -3287.7378     -3287.7378      274.92077      274.92077      47183.26       47183.26       244.20925      244.20925    
     29000  -3218.1901     -3218.1901     -3289.3009     -3289.3009      275.20641      275.20641      47242.354      47242.354      11.844761      11.844761    
Loop time of 17.4168 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.961 ns/day, 4.838 hours/ns, 57.416 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    | 17.229     | 17.229     | 17.229     |   0.0 | 98.92
Neigh   | 0.10847    | 0.10847    | 0.10847    |   0.0 |  0.62
Comm    | 0.013451   | 0.013451   | 0.013451   |   0.0 |  0.08
Output  | 2.9917e-05 | 2.9917e-05 | 2.9917e-05 |   0.0 |  0.00
Modify  | 0.061544   | 0.061544   | 0.061544   |   0.0 |  0.35
Other   |            | 0.004567   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3347 ave        3347 max        3347 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119732 ave      119732 max      119732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119732
Ave neighs/atom = 59.866
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.859325571592, Press = 1.23954571963842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3218.1901     -3218.1901     -3289.3009     -3289.3009      275.20641      275.20641      47242.354      47242.354      11.844761      11.844761    
     30000  -3217.8478     -3217.8478     -3286.5199     -3286.5199      265.7684       265.7684       47285.473      47285.473     -250.93798     -250.93798    
Loop time of 17.3779 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.972 ns/day, 4.827 hours/ns, 57.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    | 17.195     | 17.195     | 17.195     |   0.0 | 98.95
Neigh   | 0.10345    | 0.10345    | 0.10345    |   0.0 |  0.60
Comm    | 0.013373   | 0.013373   | 0.013373   |   0.0 |  0.08
Output  | 2.2232e-05 | 2.2232e-05 | 2.2232e-05 |   0.0 |  0.00
Modify  | 0.061619   | 0.061619   | 0.061619   |   0.0 |  0.35
Other   |            | 0.004575   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3313 ave        3313 max        3313 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119680 ave      119680 max      119680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119680
Ave neighs/atom = 59.84
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968615065462, Press = 0.39369977348402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3217.8478     -3217.8478     -3286.5199     -3286.5199      265.7684       265.7684       47285.473      47285.473     -250.93798     -250.93798    
     31000  -3215.84       -3215.84       -3287.5893     -3287.5893      277.67729      277.67729      47112.248      47112.248      333.48331      333.48331    
Loop time of 17.3606 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.977 ns/day, 4.822 hours/ns, 57.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    | 17.172     | 17.172     | 17.172     |   0.0 | 98.92
Neigh   | 0.10859    | 0.10859    | 0.10859    |   0.0 |  0.63
Comm    | 0.013419   | 0.013419   | 0.013419   |   0.0 |  0.08
Output  | 3.0197e-05 | 3.0197e-05 | 3.0197e-05 |   0.0 |  0.00
Modify  | 0.061591   | 0.061591   | 0.061591   |   0.0 |  0.35
Other   |            | 0.004586   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3339 ave        3339 max        3339 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119818 ave      119818 max      119818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119818
Ave neighs/atom = 59.909
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.984101512933, Press = 0.684687582584166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3215.84       -3215.84       -3287.5893     -3287.5893      277.67729      277.67729      47112.248      47112.248      333.48331      333.48331    
     32000  -3214.1188     -3214.1188     -3285.1457     -3285.1457      274.88164      274.88164      47460.403      47460.403     -386.29096     -386.29096    
Loop time of 17.3292 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.986 ns/day, 4.814 hours/ns, 57.706 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    | 17.141     | 17.141     | 17.141     |   0.0 | 98.91
Neigh   | 0.10875    | 0.10875    | 0.10875    |   0.0 |  0.63
Comm    | 0.013385   | 0.013385   | 0.013385   |   0.0 |  0.08
Output  | 2.3033e-05 | 2.3033e-05 | 2.3033e-05 |   0.0 |  0.00
Modify  | 0.061569   | 0.061569   | 0.061569   |   0.0 |  0.36
Other   |            | 0.004562   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3335 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119500 ave      119500 max      119500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119500
Ave neighs/atom = 59.75
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.995075005008, Press = 1.68388550545099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3214.1188     -3214.1188     -3285.1457     -3285.1457      274.88164      274.88164      47460.403      47460.403     -386.29096     -386.29096    
     33000  -3218.0914     -3218.0914     -3287.3531     -3287.3531      268.04996      268.04996      47362.056      47362.056     -242.64737     -242.64737    
Loop time of 17.3086 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.992 ns/day, 4.808 hours/ns, 57.775 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    | 17.116     | 17.116     | 17.116     |   0.0 | 98.89
Neigh   | 0.11298    | 0.11298    | 0.11298    |   0.0 |  0.65
Comm    | 0.013455   | 0.013455   | 0.013455   |   0.0 |  0.08
Output  | 3.1609e-05 | 3.1609e-05 | 3.1609e-05 |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.36
Other   |            | 0.004545   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3317 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119216 ave      119216 max      119216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119216
Ave neighs/atom = 59.608
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.079328385614, Press = -0.628696593555145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3218.0914     -3218.0914     -3287.3531     -3287.3531      268.04996      268.04996      47362.056      47362.056     -242.64737     -242.64737    
     34000  -3215.4085     -3215.4085     -3287.9181     -3287.9181      280.61967      280.61967      47153.044      47153.044      110.78137      110.78137    
Loop time of 17.3314 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.985 ns/day, 4.814 hours/ns, 57.699 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    | 17.144     | 17.144     | 17.144     |   0.0 | 98.92
Neigh   | 0.10833    | 0.10833    | 0.10833    |   0.0 |  0.63
Comm    | 0.013416   | 0.013416   | 0.013416   |   0.0 |  0.08
Output  | 2.9646e-05 | 2.9646e-05 | 2.9646e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.36
Other   |            | 0.00457    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3316 ave        3316 max        3316 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119718 ave      119718 max      119718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119718
Ave neighs/atom = 59.859
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.144251343706, Press = 0.342535619247253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3215.4085     -3215.4085     -3287.9181     -3287.9181      280.61967      280.61967      47153.044      47153.044      110.78137      110.78137    
     35000  -3215.5799     -3215.5799     -3287.0379     -3287.0379      276.55008      276.55008      47317.441      47317.441     -161.37843     -161.37843    
Loop time of 17.3103 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.991 ns/day, 4.808 hours/ns, 57.769 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.127     | 17.127     | 17.127     |   0.0 | 98.94
Neigh   | 0.10408    | 0.10408    | 0.10408    |   0.0 |  0.60
Comm    | 0.013272   | 0.013272   | 0.013272   |   0.0 |  0.08
Output  | 2.1982e-05 | 2.1982e-05 | 2.1982e-05 |   0.0 |  0.00
Modify  | 0.061555   | 0.061555   | 0.061555   |   0.0 |  0.36
Other   |            | 0.004658   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3328 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119654 ave      119654 max      119654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119654
Ave neighs/atom = 59.827
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.162481094103, Press = 1.06566986344998
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3215.5799     -3215.5799     -3287.0379     -3287.0379      276.55008      276.55008      47317.441      47317.441     -161.37843     -161.37843    
     36000  -3218.1818     -3218.1818     -3289.5258     -3289.5258      276.10867      276.10867      47325.666      47325.666     -157.96248     -157.96248    
Loop time of 17.3915 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.968 ns/day, 4.831 hours/ns, 57.499 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.203     | 17.203     | 17.203     |   0.0 | 98.92
Neigh   | 0.10844    | 0.10844    | 0.10844    |   0.0 |  0.62
Comm    | 0.013379   | 0.013379   | 0.013379   |   0.0 |  0.08
Output  | 3.5897e-05 | 3.5897e-05 | 3.5897e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.35
Other   |            | 0.004646   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3305 ave        3305 max        3305 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119338 ave      119338 max      119338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119338
Ave neighs/atom = 59.669
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.174687876778, Press = 0.250960304303841
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3218.1818     -3218.1818     -3289.5258     -3289.5258      276.10867      276.10867      47325.666      47325.666     -157.96248     -157.96248    
     37000  -3215.4113     -3215.4113     -3286.0349     -3286.0349      273.32072      273.32072      47212.694      47212.694      87.501695      87.501695    
Loop time of 17.3694 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.974 ns/day, 4.825 hours/ns, 57.573 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    | 17.181     | 17.181     | 17.181     |   0.0 | 98.92
Neigh   | 0.1084     | 0.1084     | 0.1084     |   0.0 |  0.62
Comm    | 0.013401   | 0.013401   | 0.013401   |   0.0 |  0.08
Output  | 2.2281e-05 | 2.2281e-05 | 2.2281e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.35
Other   |            | 0.00456    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3333 ave        3333 max        3333 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119770 ave      119770 max      119770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119770
Ave neighs/atom = 59.885
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.245608747194, Press = -0.337508823210924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3215.4113     -3215.4113     -3286.0349     -3286.0349      273.32072      273.32072      47212.694      47212.694      87.501695      87.501695    
     38000  -3213.8317     -3213.8317     -3286.2025     -3286.2025      280.08276      280.08276      47138.383      47138.383      396.47066      396.47066    
Loop time of 17.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.971 ns/day, 4.828 hours/ns, 57.537 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 17.187     | 17.187     | 17.187     |   0.0 | 98.89
Neigh   | 0.11325    | 0.11325    | 0.11325    |   0.0 |  0.65
Comm    | 0.013384   | 0.013384   | 0.013384   |   0.0 |  0.08
Output  | 2.2884e-05 | 2.2884e-05 | 2.2884e-05 |   0.0 |  0.00
Modify  | 0.061533   | 0.061533   | 0.061533   |   0.0 |  0.35
Other   |            | 0.004524   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3321 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119920 ave      119920 max      119920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119920
Ave neighs/atom = 59.96
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.268526442361, Press = 1.61108830684709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3213.8317     -3213.8317     -3286.2025     -3286.2025      280.08276      280.08276      47138.383      47138.383      396.47066      396.47066    
     39000  -3217.215      -3217.215      -3287.7939     -3287.7939      273.14794      273.14794      47511.371      47511.371     -485.00007     -485.00007    
Loop time of 17.3667 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.975 ns/day, 4.824 hours/ns, 57.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    | 17.178     | 17.178     | 17.178     |   0.0 | 98.92
Neigh   | 0.10879    | 0.10879    | 0.10879    |   0.0 |  0.63
Comm    | 0.013396   | 0.013396   | 0.013396   |   0.0 |  0.08
Output  | 2.2051e-05 | 2.2051e-05 | 2.2051e-05 |   0.0 |  0.00
Modify  | 0.061481   | 0.061481   | 0.061481   |   0.0 |  0.35
Other   |            | 0.004556   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3310 ave        3310 max        3310 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119002 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.269590877617, Press = 0.584503877606958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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) = 3.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3217.215      -3217.215      -3287.7939     -3287.7939      273.14794      273.14794      47511.371      47511.371     -485.00007     -485.00007    
     40000  -3217.2599     -3217.2599     -3288.3808     -3288.3808      275.24513      275.24513      47232.614      47232.614      138.41807      138.41807    
Loop time of 17.3623 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.976 ns/day, 4.823 hours/ns, 57.596 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    | 17.179     | 17.179     | 17.179     |   0.0 | 98.95
Neigh   | 0.10356    | 0.10356    | 0.10356    |   0.0 |  0.60
Comm    | 0.013326   | 0.013326   | 0.013326   |   0.0 |  0.08
Output  | 3.173e-05  | 3.173e-05  | 3.173e-05  |   0.0 |  0.00
Modify  | 0.061547   | 0.061547   | 0.061547   |   0.0 |  0.35
Other   |            | 0.004621   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3344 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119444 ave      119444 max      119444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119444
Ave neighs/atom = 59.722
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${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
47236.0207697653

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0