# 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.031088910996914*${_u_distance}
variable latticeconst_converted equal 3.031088910996914*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891099691
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.000 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoLee_2013_VPdY__MO_046547823135_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_046547823135_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10524.253     -10524.253     -10600         -10600          293.15         293.15         27848.129      27848.129      2905.2976      2905.2976    
      1000  -10441.898     -10441.898     -10524.384     -10524.384      319.22967      319.22967      28071.997      28071.997     -1746.6929     -1746.6929    
Loop time of 69.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.245 ns/day, 19.282 hours/ns, 14.406 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    | 69.33      | 69.33      | 69.33      |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019718   | 0.019718   | 0.019718   |   0.0 |  0.03
Output  | 0.00016763 | 0.00016763 | 0.00016763 |   0.0 |  0.00
Modify  | 0.060123   | 0.060123   | 0.060123   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       336000 ave      336000 max      336000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 336000
Ave neighs/atom = 168
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10441.898     -10441.898     -10524.384     -10524.384      319.22967      319.22967      28071.997      28071.997     -1746.6929     -1746.6929    
      2000  -10445.504     -10445.504     -10522.254     -10522.254      297.02906      297.02906      28054.604      28054.604     -712.02626     -712.02626    
Loop time of 69.3153 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.246 ns/day, 19.254 hours/ns, 14.427 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.23      | 69.23      | 69.23      |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01929    | 0.01929    | 0.01929    |   0.0 |  0.03
Output  | 9.1222e-05 | 9.1222e-05 | 9.1222e-05 |   0.0 |  0.00
Modify  | 0.059524   | 0.059524   | 0.059524   |   0.0 |  0.09
Other   |            | 0.006023   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324564 ave      324564 max      324564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324564
Ave neighs/atom = 162.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10445.504     -10445.504     -10522.254     -10522.254      297.02906      297.02906      28054.604      28054.604     -712.02626     -712.02626    
      3000  -10444.915     -10444.915     -10520.059     -10520.059      290.81287      290.81287      28010.515      28010.515      1791.5515      1791.5515    
Loop time of 69.5112 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.243 ns/day, 19.309 hours/ns, 14.386 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.426     | 69.426     | 69.426     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019358   | 0.019358   | 0.019358   |   0.0 |  0.03
Output  | 4.6718e-05 | 4.6718e-05 | 4.6718e-05 |   0.0 |  0.00
Modify  | 0.059473   | 0.059473   | 0.059473   |   0.0 |  0.09
Other   |            | 0.005998   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324354 ave      324354 max      324354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324354
Ave neighs/atom = 162.177
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10444.915     -10444.915     -10520.059     -10520.059      290.81287      290.81287      28010.515      28010.515      1791.5515      1791.5515    
      4000  -10444.654     -10444.654     -10517.275     -10517.275      281.04808      281.04808      28040.941      28040.941      192.58121      192.58121    
Loop time of 69.5726 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.242 ns/day, 19.326 hours/ns, 14.373 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    | 69.488     | 69.488     | 69.488     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01933    | 0.01933    | 0.01933    |   0.0 |  0.03
Output  | 6.9732e-05 | 6.9732e-05 | 6.9732e-05 |   0.0 |  0.00
Modify  | 0.05953    | 0.05953    | 0.05953    |   0.0 |  0.09
Other   |            | 0.006047   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324400 ave      324400 max      324400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324400
Ave neighs/atom = 162.2
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10444.654     -10444.654     -10517.275     -10517.275      281.04808      281.04808      28040.941      28040.941      192.58121      192.58121    
      5000  -10443.647     -10443.647     -10520.943     -10520.943      299.14295      299.14295      28088.505      28088.505     -2260.2538     -2260.2538    
Loop time of 69.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.379 hours/ns, 14.334 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    | 69.681     | 69.681     | 69.681     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019463   | 0.019463   | 0.019463   |   0.0 |  0.03
Output  | 4.4064e-05 | 4.4064e-05 | 4.4064e-05 |   0.0 |  0.00
Modify  | 0.059893   | 0.059893   | 0.059893   |   0.0 |  0.09
Other   |            | 0.006068   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       323936 ave      323936 max      323936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323936
Ave neighs/atom = 161.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.811332039995, Press = -357.217233756331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10443.647     -10443.647     -10520.943     -10520.943      299.14295      299.14295      28088.505      28088.505     -2260.2538     -2260.2538    
      6000  -10443.558     -10443.558     -10519.883     -10519.883      295.38835      295.38835      27980.475      27980.475      3507.9729      3507.9729    
Loop time of 69.7803 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.383 hours/ns, 14.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    | 69.693     | 69.693     | 69.693     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01936    | 0.01936    | 0.01936    |   0.0 |  0.03
Output  | 5.3652e-05 | 5.3652e-05 | 5.3652e-05 |   0.0 |  0.00
Modify  | 0.062041   | 0.062041   | 0.062041   |   0.0 |  0.09
Other   |            | 0.006092   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       323992 ave      323992 max      323992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323992
Ave neighs/atom = 161.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.625270765768, Press = -13.3499083705411
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10443.558     -10443.558     -10519.883     -10519.883      295.38835      295.38835      27980.475      27980.475      3507.9729      3507.9729    
      7000  -10444.393     -10444.393     -10518.323     -10518.323      286.11548      286.11548      28044.034      28044.034     -70.329559     -70.329559    
Loop time of 69.8464 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.402 hours/ns, 14.317 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    | 69.759     | 69.759     | 69.759     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019338   | 0.019338   | 0.019338   |   0.0 |  0.03
Output  | 5.6055e-05 | 5.6055e-05 | 5.6055e-05 |   0.0 |  0.00
Modify  | 0.061915   | 0.061915   | 0.061915   |   0.0 |  0.09
Other   |            | 0.006119   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325426 ave      325426 max      325426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325426
Ave neighs/atom = 162.713
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.78517322198, Press = 31.8758204127734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10444.393     -10444.393     -10518.323     -10518.323      286.11548      286.11548      28044.034      28044.034     -70.329559     -70.329559    
      8000  -10444.071     -10444.071     -10518.846     -10518.846      289.38633      289.38633      28061.951      28061.951     -1031.2359     -1031.2359    
Loop time of 69.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.240 ns/day, 19.357 hours/ns, 14.350 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.598     | 69.598     | 69.598     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019358   | 0.019358   | 0.019358   |   0.0 |  0.03
Output  | 3.156e-05  | 3.156e-05  | 3.156e-05  |   0.0 |  0.00
Modify  | 0.061931   | 0.061931   | 0.061931   |   0.0 |  0.09
Other   |            | 0.006075   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324342 ave      324342 max      324342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324342
Ave neighs/atom = 162.171
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.449853803612, Press = -3.27212826093794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10444.071     -10444.071     -10518.846     -10518.846      289.38633      289.38633      28061.951      28061.951     -1031.2359     -1031.2359    
      9000  -10445.264     -10445.264     -10518.602     -10518.602      283.82271      283.82271      28005.572      28005.572      1896.0952      1896.0952    
Loop time of 69.7946 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.387 hours/ns, 14.328 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.707     | 69.707     | 69.707     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019418   | 0.019418   | 0.019418   |   0.0 |  0.03
Output  | 4.742e-05  | 4.742e-05  | 4.742e-05  |   0.0 |  0.00
Modify  | 0.061879   | 0.061879   | 0.061879   |   0.0 |  0.09
Other   |            | 0.006102   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324106 ave      324106 max      324106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324106
Ave neighs/atom = 162.053
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.447250193175, Press = 4.90447745304031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10445.264     -10445.264     -10518.602     -10518.602      283.82271      283.82271      28005.572      28005.572      1896.0952      1896.0952    
     10000  -10444.504     -10444.504     -10519.111     -10519.111      288.73752      288.73752      28052.799      28052.799     -683.95741     -683.95741    
Loop time of 69.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.395 hours/ns, 14.322 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    | 69.733     | 69.733     | 69.733     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019392   | 0.019392   | 0.019392   |   0.0 |  0.03
Output  | 4.5926e-05 | 4.5926e-05 | 4.5926e-05 |   0.0 |  0.00
Modify  | 0.062012   | 0.062012   | 0.062012   |   0.0 |  0.09
Other   |            | 0.006118   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324766 ave      324766 max      324766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324766
Ave neighs/atom = 162.383
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.122948667455, Press = 14.6204635381812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10444.504     -10444.504     -10519.111     -10519.111      288.73752      288.73752      28052.799      28052.799     -683.95741     -683.95741    
     11000  -10446.109     -10446.109     -10523.889     -10523.889      301.0159       301.0159       28080.467      28080.467     -2376.4281     -2376.4281    
Loop time of 69.8409 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.400 hours/ns, 14.318 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    | 69.753     | 69.753     | 69.753     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019526   | 0.019526   | 0.019526   |   0.0 |  0.03
Output  | 3.2582e-05 | 3.2582e-05 | 3.2582e-05 |   0.0 |  0.00
Modify  | 0.061968   | 0.061968   | 0.061968   |   0.0 |  0.09
Other   |            | 0.006076   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324114 ave      324114 max      324114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324114
Ave neighs/atom = 162.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.290892133137, Press = -8.25777409049529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10446.109     -10446.109     -10523.889     -10523.889      301.0159       301.0159       28080.467      28080.467     -2376.4281     -2376.4281    
     12000  -10443.589     -10443.589     -10521.467     -10521.467      301.39696      301.39696      27992.463      27992.463      2533.6319      2533.6319    
Loop time of 69.9224 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.423 hours/ns, 14.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    | 69.835     | 69.835     | 69.835     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019444   | 0.019444   | 0.019444   |   0.0 |  0.03
Output  | 3.0518e-05 | 3.0518e-05 | 3.0518e-05 |   0.0 |  0.00
Modify  | 0.061805   | 0.061805   | 0.061805   |   0.0 |  0.09
Other   |            | 0.006045   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324224 ave      324224 max      324224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324224
Ave neighs/atom = 162.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.427472567495, Press = 2.06567997306899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10443.589     -10443.589     -10521.467     -10521.467      301.39696      301.39696      27992.463      27992.463      2533.6319      2533.6319    
     13000  -10440.104     -10440.104     -10516.714     -10516.714      296.48742      296.48742      28058.606      28058.606     -384.53817     -384.53817    
Loop time of 69.8347 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.399 hours/ns, 14.320 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    | 69.747     | 69.747     | 69.747     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01922    | 0.01922    | 0.01922    |   0.0 |  0.03
Output  | 4.747e-05  | 4.747e-05  | 4.747e-05  |   0.0 |  0.00
Modify  | 0.061959   | 0.061959   | 0.061959   |   0.0 |  0.09
Other   |            | 0.006082   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325266 ave      325266 max      325266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325266
Ave neighs/atom = 162.633
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.649775248229, Press = 6.9731761244564
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10440.104     -10440.104     -10516.714     -10516.714      296.48742      296.48742      28058.606      28058.606     -384.53817     -384.53817    
     14000  -10445.642     -10445.642     -10523.08      -10523.08       299.69524      299.69524      28052.701      28052.701     -716.35816     -716.35816    
Loop time of 69.6918 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.240 ns/day, 19.359 hours/ns, 14.349 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    | 69.604     | 69.604     | 69.604     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019304   | 0.019304   | 0.019304   |   0.0 |  0.03
Output  | 0.00013747 | 0.00013747 | 0.00013747 |   0.0 |  0.00
Modify  | 0.061897   | 0.061897   | 0.061897   |   0.0 |  0.09
Other   |            | 0.006078   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324006 ave      324006 max      324006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324006
Ave neighs/atom = 162.003
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885483221122, Press = 0.739235849443857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10445.642     -10445.642     -10523.08      -10523.08       299.69524      299.69524      28052.701      28052.701     -716.35816     -716.35816    
     15000  -10446.636     -10446.636     -10521.139     -10521.139      288.33598      288.33598      28021.078      28021.078      1080.8431      1080.8431    
Loop time of 69.9138 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.420 hours/ns, 14.303 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.826     | 69.826     | 69.826     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019283   | 0.019283   | 0.019283   |   0.0 |  0.03
Output  | 5.9392e-05 | 5.9392e-05 | 5.9392e-05 |   0.0 |  0.00
Modify  | 0.061936   | 0.061936   | 0.061936   |   0.0 |  0.09
Other   |            | 0.006077   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324742 ave      324742 max      324742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324742
Ave neighs/atom = 162.371
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781295860785, Press = 3.14434022715239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10446.636     -10446.636     -10521.139     -10521.139      288.33598      288.33598      28021.078      28021.078      1080.8431      1080.8431    
     16000  -10446.02      -10446.02      -10522.523     -10522.523      296.0729       296.0729       28063.256      28063.256     -1262.1203     -1262.1203    
Loop time of 69.7943 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.387 hours/ns, 14.328 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.707     | 69.707     | 69.707     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019374   | 0.019374   | 0.019374   |   0.0 |  0.03
Output  | 3.5898e-05 | 3.5898e-05 | 3.5898e-05 |   0.0 |  0.00
Modify  | 0.061989   | 0.061989   | 0.061989   |   0.0 |  0.09
Other   |            | 0.00607    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324854 ave      324854 max      324854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324854
Ave neighs/atom = 162.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887887381615, Press = 5.88994055714764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10446.02      -10446.02      -10522.523     -10522.523      296.0729       296.0729       28063.256      28063.256     -1262.1203     -1262.1203    
     17000  -10442.404     -10442.404     -10518.233     -10518.233      293.467        293.467        28066.208      28066.208     -1165.3175     -1165.3175    
Loop time of 69.7737 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.382 hours/ns, 14.332 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    | 69.686     | 69.686     | 69.686     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019315   | 0.019315   | 0.019315   |   0.0 |  0.03
Output  | 2.9796e-05 | 2.9796e-05 | 2.9796e-05 |   0.0 |  0.00
Modify  | 0.061916   | 0.061916   | 0.061916   |   0.0 |  0.09
Other   |            | 0.006033   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324522 ave      324522 max      324522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324522
Ave neighs/atom = 162.261
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.025452757433, Press = -4.08078081633993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10442.404     -10442.404     -10518.233     -10518.233      293.467        293.467        28066.208      28066.208     -1165.3175     -1165.3175    
     18000  -10446.721     -10446.721     -10520.576     -10520.576      285.82524      285.82524      27996.782      27996.782      2252.2172      2252.2172    
Loop time of 69.9864 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.441 hours/ns, 14.288 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    | 69.898     | 69.898     | 69.898     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019665   | 0.019665   | 0.019665   |   0.0 |  0.03
Output  | 0.00010917 | 0.00010917 | 0.00010917 |   0.0 |  0.00
Modify  | 0.062548   | 0.062548   | 0.062548   |   0.0 |  0.09
Other   |            | 0.006057   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324172 ave      324172 max      324172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324172
Ave neighs/atom = 162.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.179602659028, Press = 2.35687022417814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10446.721     -10446.721     -10520.576     -10520.576      285.82524      285.82524      27996.782      27996.782      2252.2172      2252.2172    
     19000  -10444.761     -10444.761     -10521.817     -10521.817      298.21673      298.21673      28055.908      28055.908     -862.68994     -862.68994    
Loop time of 70.0397 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.455 hours/ns, 14.278 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    | 69.95      | 69.95      | 69.95      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02034    | 0.02034    | 0.02034    |   0.0 |  0.03
Output  | 4.5937e-05 | 4.5937e-05 | 4.5937e-05 |   0.0 |  0.00
Modify  | 0.063044   | 0.063044   | 0.063044   |   0.0 |  0.09
Other   |            | 0.006083   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325044 ave      325044 max      325044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325044
Ave neighs/atom = 162.522
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.13749580536, Press = 3.69850717586713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10444.761     -10444.761     -10521.817     -10521.817      298.21673      298.21673      28055.908      28055.908     -862.68994     -862.68994    
     20000  -10441.286     -10441.286     -10519.461     -10519.461      302.5463       302.5463       28057.509      28057.509     -705.44145     -705.44145    
Loop time of 69.8685 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.408 hours/ns, 14.313 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.781     | 69.781     | 69.781     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019617   | 0.019617   | 0.019617   |   0.0 |  0.03
Output  | 3.5938e-05 | 3.5938e-05 | 3.5938e-05 |   0.0 |  0.00
Modify  | 0.06232    | 0.06232    | 0.06232    |   0.0 |  0.09
Other   |            | 0.005975   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324538 ave      324538 max      324538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324538
Ave neighs/atom = 162.269
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.152947203416, Press = 0.296029058610048
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10441.286     -10441.286     -10519.461     -10519.461      302.5463       302.5463       28057.509      28057.509     -705.44145     -705.44145    
     21000  -10446.242     -10446.242     -10520.782     -10520.782      288.4753       288.4753       28027.867      28027.867      678.05435      678.05435    
Loop time of 69.8496 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.403 hours/ns, 14.316 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.762     | 69.762     | 69.762     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019517   | 0.019517   | 0.019517   |   0.0 |  0.03
Output  | 3.7982e-05 | 3.7982e-05 | 3.7982e-05 |   0.0 |  0.00
Modify  | 0.062098   | 0.062098   | 0.062098   |   0.0 |  0.09
Other   |            | 0.005948   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324052 ave      324052 max      324052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324052
Ave neighs/atom = 162.026
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.257770841603, Press = 1.54763227804721
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10446.242     -10446.242     -10520.782     -10520.782      288.4753       288.4753       28027.867      28027.867      678.05435      678.05435    
     22000  -10443.073     -10443.073     -10520.527     -10520.527      299.75752      299.75752      28053.682      28053.682     -646.88972     -646.88972    
Loop time of 70.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.502 hours/ns, 14.244 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.119     | 70.119     | 70.119     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019477   | 0.019477   | 0.019477   |   0.0 |  0.03
Output  | 3.4054e-05 | 3.4054e-05 | 3.4054e-05 |   0.0 |  0.00
Modify  | 0.062637   | 0.062637   | 0.062637   |   0.0 |  0.09
Other   |            | 0.005959   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324574 ave      324574 max      324574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324574
Ave neighs/atom = 162.287
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.389769683721, Press = 1.43575106496511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10443.073     -10443.073     -10520.527     -10520.527      299.75752      299.75752      28053.682      28053.682     -646.88972     -646.88972    
     23000  -10444.139     -10444.139     -10519.29      -10519.29       290.84098      290.84098      28043.907      28043.907      6.5058157      6.5058157    
Loop time of 69.8868 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.413 hours/ns, 14.309 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.798     | 69.798     | 69.798     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019893   | 0.019893   | 0.019893   |   0.0 |  0.03
Output  | 5.1858e-05 | 5.1858e-05 | 5.1858e-05 |   0.0 |  0.00
Modify  | 0.0628     | 0.0628     | 0.0628     |   0.0 |  0.09
Other   |            | 0.006056   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324196 ave      324196 max      324196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324196
Ave neighs/atom = 162.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441830005856, Press = -0.0156107279291429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10444.139     -10444.139     -10519.29      -10519.29       290.84098      290.84098      28043.907      28043.907      6.5058157      6.5058157    
     24000  -10447.216     -10447.216     -10522.008     -10522.008      289.45209      289.45209      28017.508      28017.508      1170.5257      1170.5257    
Loop time of 69.9333 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.426 hours/ns, 14.299 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.845     | 69.845     | 69.845     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019785   | 0.019785   | 0.019785   |   0.0 |  0.03
Output  | 4.6528e-05 | 4.6528e-05 | 4.6528e-05 |   0.0 |  0.00
Modify  | 0.062853   | 0.062853   | 0.062853   |   0.0 |  0.09
Other   |            | 0.006021   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324334 ave      324334 max      324334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324334
Ave neighs/atom = 162.167
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.44728434443, Press = 2.59721727339554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10447.216     -10447.216     -10522.008     -10522.008      289.45209      289.45209      28017.508      28017.508      1170.5257      1170.5257    
     25000  -10444.327     -10444.327     -10520.126     -10520.126      293.34811      293.34811      28079.857      28079.857     -2093.1128     -2093.1128    
Loop time of 69.8872 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.413 hours/ns, 14.309 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.8       | 69.8       | 69.8       |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019257   | 0.019257   | 0.019257   |   0.0 |  0.03
Output  | 6.7958e-05 | 6.7958e-05 | 6.7958e-05 |   0.0 |  0.00
Modify  | 0.061962   | 0.061962   | 0.061962   |   0.0 |  0.09
Other   |            | 0.006042   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325138 ave      325138 max      325138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325138
Ave neighs/atom = 162.569
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.448920235603, Press = 1.61870405617644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10444.327     -10444.327     -10520.126     -10520.126      293.34811      293.34811      28079.857      28079.857     -2093.1128     -2093.1128    
     26000  -10446.147     -10446.147     -10521.12      -10521.12       290.15132      290.15132      28037.557      28037.557      149.86145      149.86145    
Loop time of 70.4889 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.226 ns/day, 19.580 hours/ns, 14.187 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.399     | 70.399     | 70.399     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020055   | 0.020055   | 0.020055   |   0.0 |  0.03
Output  | 4.7069e-05 | 4.7069e-05 | 4.7069e-05 |   0.0 |  0.00
Modify  | 0.063287   | 0.063287   | 0.063287   |   0.0 |  0.09
Other   |            | 0.006024   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324258 ave      324258 max      324258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324258
Ave neighs/atom = 162.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.466965311745, Press = -2.08554229617181
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10446.147     -10446.147     -10521.12      -10521.12       290.15132      290.15132      28037.557      28037.557      149.86145      149.86145    
     27000  -10445.017     -10445.017     -10521.248     -10521.248      295.02231      295.02231      27999.883      27999.883      2160.6405      2160.6405    
Loop time of 70.1695 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.492 hours/ns, 14.251 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.08      | 70.08      | 70.08      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019959   | 0.019959   | 0.019959   |   0.0 |  0.03
Output  | 7.8739e-05 | 7.8739e-05 | 7.8739e-05 |   0.0 |  0.00
Modify  | 0.063245   | 0.063245   | 0.063245   |   0.0 |  0.09
Other   |            | 0.006055   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324800 ave      324800 max      324800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324800
Ave neighs/atom = 162.4
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.469584535423, Press = 2.26933126741524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10445.017     -10445.017     -10521.248     -10521.248      295.02231      295.02231      27999.883      27999.883      2160.6405      2160.6405    
     28000  -10443.734     -10443.734     -10520.2       -10520.2        295.93175      295.93175      28059.366      28059.366     -886.34794     -886.34794    
Loop time of 70.1849 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.496 hours/ns, 14.248 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.096     | 70.096     | 70.096     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019789   | 0.019789   | 0.019789   |   0.0 |  0.03
Output  | 5.2219e-05 | 5.2219e-05 | 5.2219e-05 |   0.0 |  0.00
Modify  | 0.062834   | 0.062834   | 0.062834   |   0.0 |  0.09
Other   |            | 0.006036   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324888 ave      324888 max      324888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324888
Ave neighs/atom = 162.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.345998496075, Press = 1.30278768843064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10443.734     -10443.734     -10520.2       -10520.2        295.93175      295.93175      28059.366      28059.366     -886.34794     -886.34794    
     29000  -10446.769     -10446.769     -10522.556     -10522.556      293.30622      293.30622      28040.608      28040.608     -203.20751     -203.20751    
Loop time of 69.9115 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.420 hours/ns, 14.304 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.822     | 69.822     | 69.822     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020531   | 0.020531   | 0.020531   |   0.0 |  0.03
Output  | 4.736e-05  | 4.736e-05  | 4.736e-05  |   0.0 |  0.00
Modify  | 0.063289   | 0.063289   | 0.063289   |   0.0 |  0.09
Other   |            | 0.006051   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324076 ave      324076 max      324076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324076
Ave neighs/atom = 162.038
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.288914002904, Press = -0.307318074013096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10446.769     -10446.769     -10522.556     -10522.556      293.30622      293.30622      28040.608      28040.608     -203.20751     -203.20751    
     30000  -10447.403     -10447.403     -10523.269     -10523.269      293.6097       293.6097       28017.069      28017.069      970.85102      970.85102    
Loop time of 70.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.477 hours/ns, 14.262 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.027     | 70.027     | 70.027     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02008    | 0.02008    | 0.02008    |   0.0 |  0.03
Output  | 3.0086e-05 | 3.0086e-05 | 3.0086e-05 |   0.0 |  0.00
Modify  | 0.062804   | 0.062804   | 0.062804   |   0.0 |  0.09
Other   |            | 0.006005   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324922 ave      324922 max      324922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324922
Ave neighs/atom = 162.461
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.233279382035, Press = 0.958686735564799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10447.403     -10447.403     -10523.269     -10523.269      293.6097       293.6097       28017.069      28017.069      970.85102      970.85102    
     31000  -10445.315     -10445.315     -10522.166     -10522.166      297.42357      297.42357      28064.14       28064.14      -1323.434      -1323.434     
Loop time of 69.9996 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.444 hours/ns, 14.286 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.909     | 69.909     | 69.909     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02065    | 0.02065    | 0.02065    |   0.0 |  0.03
Output  | 4.8512e-05 | 4.8512e-05 | 4.8512e-05 |   0.0 |  0.00
Modify  | 0.063499   | 0.063499   | 0.063499   |   0.0 |  0.09
Other   |            | 0.006089   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325188 ave      325188 max      325188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325188
Ave neighs/atom = 162.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.26955628928, Press = 2.22545425281387
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10445.315     -10445.315     -10522.166     -10522.166      297.42357      297.42357      28064.14       28064.14      -1323.434      -1323.434     
     32000  -10445.122     -10445.122     -10519.398     -10519.398      287.45418      287.45418      28075.728      28075.728     -1727.3653     -1727.3653    
Loop time of 70.0566 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.460 hours/ns, 14.274 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.967     | 69.967     | 69.967     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020247   | 0.020247   | 0.020247   |   0.0 |  0.03
Output  | 3.4715e-05 | 3.4715e-05 | 3.4715e-05 |   0.0 |  0.00
Modify  | 0.063075   | 0.063075   | 0.063075   |   0.0 |  0.09
Other   |            | 0.006058   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324394 ave      324394 max      324394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324394
Ave neighs/atom = 162.197
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.307791705349, Press = -2.05433873732332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10445.122     -10445.122     -10519.398     -10519.398      287.45418      287.45418      28075.728      28075.728     -1727.3653     -1727.3653    
     33000  -10446.211     -10446.211     -10522.725     -10522.725      296.11682      296.11682      27981.274      27981.274      3201.3703      3201.3703    
Loop time of 70.0461 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.457 hours/ns, 14.276 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.956     | 69.956     | 69.956     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020674   | 0.020674   | 0.020674   |   0.0 |  0.03
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.063445   | 0.063445   | 0.063445   |   0.0 |  0.09
Other   |            | 0.006069   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324048 ave      324048 max      324048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324048
Ave neighs/atom = 162.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.342621267137, Press = 0.775828492009934
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10446.211     -10446.211     -10522.725     -10522.725      296.11682      296.11682      27981.274      27981.274      3201.3703      3201.3703    
     34000  -10444.569     -10444.569     -10519.424     -10519.424      289.69607      289.69607      28056.29       28056.29      -866.40465     -866.40465    
Loop time of 70.1065 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.474 hours/ns, 14.264 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.017     | 70.017     | 70.017     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020134   | 0.020134   | 0.020134   |   0.0 |  0.03
Output  | 4.8391e-05 | 4.8391e-05 | 4.8391e-05 |   0.0 |  0.00
Modify  | 0.062956   | 0.062956   | 0.062956   |   0.0 |  0.09
Other   |            | 0.006028   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       325900 ave      325900 max      325900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325900
Ave neighs/atom = 162.95
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.254337997937, Press = 1.54521084708368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10444.569     -10444.569     -10519.424     -10519.424      289.69607      289.69607      28056.29       28056.29      -866.40465     -866.40465    
     35000  -10447.53      -10447.53      -10521.943     -10521.943      287.98614      287.98614      28043.808      28043.808     -259.87364     -259.87364    
Loop time of 70.1457 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.485 hours/ns, 14.256 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.056     | 70.056     | 70.056     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020333   | 0.020333   | 0.020333   |   0.0 |  0.03
Output  | 4.9774e-05 | 4.9774e-05 | 4.9774e-05 |   0.0 |  0.00
Modify  | 0.063356   | 0.063356   | 0.063356   |   0.0 |  0.09
Other   |            | 0.006057   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       324318 ave      324318 max      324318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0