# 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.002 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_ShimLeeFleury_2011_VH__MO_072444764353_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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_072444764353_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10513.917     -10513.917     -10600         -10600          333.15         333.15         27848.129      27848.129      3301.722       3301.722     
      1000  -10419.081     -10419.081     -10513.329     -10513.329      364.75042      364.75042      28027.438      28027.438      2352.0979      2352.0979    
Loop time of 95.8325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.620 hours/ns, 10.435 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.35      | 95.35      | 95.35      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075805   | 0.075805   | 0.075805   |   0.0 |  0.08
Output  | 0.00025398 | 0.00025398 | 0.00025398 |   0.0 |  0.00
Modify  | 0.35004    | 0.35004    | 0.35004    |   0.0 |  0.37
Other   |            | 0.05658    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10419.081     -10419.081     -10513.329     -10513.329      364.75042      364.75042      28027.438      28027.438      2352.0979      2352.0979    
      2000  -10424.605     -10424.605     -10506.967     -10506.967      318.74884      318.74884      28034.493      28034.493      2059.342       2059.342     
Loop time of 101.291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.136 hours/ns, 9.873 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    | 100.8      | 100.8      | 100.8      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079575   | 0.079575   | 0.079575   |   0.0 |  0.08
Output  | 0.00020166 | 0.00020166 | 0.00020166 |   0.0 |  0.00
Modify  | 0.35338    | 0.35338    | 0.35338    |   0.0 |  0.35
Other   |            | 0.05733    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3137 ave        3137 max        3137 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:       119042 ave      119042 max      119042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119042
Ave neighs/atom = 59.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10424.605     -10424.605     -10506.967     -10506.967      318.74884      318.74884      28034.493      28034.493      2059.342       2059.342     
      3000  -10422.794     -10422.794     -10508.979     -10508.979      333.54521      333.54521      28057.409      28057.409      503.46165      503.46165    
Loop time of 101.308 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.141 hours/ns, 9.871 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.82     | 100.82     | 100.82     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079049   | 0.079049   | 0.079049   |   0.0 |  0.08
Output  | 0.00020406 | 0.00020406 | 0.00020406 |   0.0 |  0.00
Modify  | 0.35336    | 0.35336    | 0.35336    |   0.0 |  0.35
Other   |            | 0.05773    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3147 ave        3147 max        3147 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:       119192 ave      119192 max      119192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119192
Ave neighs/atom = 59.596
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10422.794     -10422.794     -10508.979     -10508.979      333.54521      333.54521      28057.409      28057.409      503.46165      503.46165    
      4000  -10422.425     -10422.425     -10511.178     -10511.178      343.48372      343.48372      28061.541      28061.541      822.23562      822.23562    
Loop time of 102.101 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.361 hours/ns, 9.794 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.61     | 101.61     | 101.61     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079556   | 0.079556   | 0.079556   |   0.0 |  0.08
Output  | 0.00023854 | 0.00023854 | 0.00023854 |   0.0 |  0.00
Modify  | 0.35487    | 0.35487    | 0.35487    |   0.0 |  0.35
Other   |            | 0.05779    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3179 ave        3179 max        3179 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:       119230 ave      119230 max      119230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119230
Ave neighs/atom = 59.615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10422.425     -10422.425     -10511.178     -10511.178      343.48372      343.48372      28061.541      28061.541      822.23562      822.23562    
      5000  -10421.425     -10421.425     -10510.163     -10510.163      343.42183      343.42183      28089.933      28089.933     -1196.1121     -1196.1121    
Loop time of 102.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.454 hours/ns, 9.762 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    | 101.94     | 101.94     | 101.94     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079337   | 0.079337   | 0.079337   |   0.0 |  0.08
Output  | 0.00016488 | 0.00016488 | 0.00016488 |   0.0 |  0.00
Modify  | 0.35896    | 0.35896    | 0.35896    |   0.0 |  0.35
Other   |            | 0.05828    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 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:       118968 ave      118968 max      118968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118968
Ave neighs/atom = 59.484
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 = 330.915292260882, Press = -1244.97124405657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10421.425     -10421.425     -10510.163     -10510.163      343.42183      343.42183      28089.933      28089.933     -1196.1121     -1196.1121    
      6000  -10422.904     -10422.904     -10507.773     -10507.773      328.45059      328.45059      28127.538      28127.538     -3161.8561     -3161.8561    
Loop time of 101.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.852 ns/day, 28.162 hours/ns, 9.863 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.87     | 100.87     | 100.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078618   | 0.078618   | 0.078618   |   0.0 |  0.08
Output  | 0.00016527 | 0.00016527 | 0.00016527 |   0.0 |  0.00
Modify  | 0.37446    | 0.37446    | 0.37446    |   0.0 |  0.37
Other   |            | 0.05754    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 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:       119032 ave      119032 max      119032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119032
Ave neighs/atom = 59.516
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 = 332.177737568654, Press = -110.892895304764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10422.904     -10422.904     -10507.773     -10507.773      328.45059      328.45059      28127.538      28127.538     -3161.8561     -3161.8561    
      7000  -10422.374     -10422.374     -10505.614     -10505.614      322.14918      322.14918      28113.089      28113.089     -2030.9023     -2030.9023    
Loop time of 102.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.587 hours/ns, 9.717 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.4      | 102.4      | 102.4      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079688   | 0.079688   | 0.079688   |   0.0 |  0.08
Output  | 0.00016792 | 0.00016792 | 0.00016792 |   0.0 |  0.00
Modify  | 0.37923    | 0.37923    | 0.37923    |   0.0 |  0.37
Other   |            | 0.058      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 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:       118984 ave      118984 max      118984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118984
Ave neighs/atom = 59.492
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 = 331.695364795133, Press = -27.1113365174824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10422.374     -10422.374     -10505.614     -10505.614      322.14918      322.14918      28113.089      28113.089     -2030.9023     -2030.9023    
      8000  -10424.997     -10424.997     -10511.972     -10511.972      336.60208      336.60208      28097.587      28097.587     -1685.4053     -1685.4053    
Loop time of 105.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.257 hours/ns, 9.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.79     | 104.79     | 104.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082123   | 0.082123   | 0.082123   |   0.0 |  0.08
Output  | 0.00016657 | 0.00016657 | 0.00016657 |   0.0 |  0.00
Modify  | 0.39533    | 0.39533    | 0.39533    |   0.0 |  0.38
Other   |            | 0.05915    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3177 ave        3177 max        3177 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:       119034 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517
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 = 331.933731200745, Press = -5.02784152346252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10424.997     -10424.997     -10511.972     -10511.972      336.60208      336.60208      28097.587      28097.587     -1685.4053     -1685.4053    
      9000  -10422.162     -10422.162     -10508.327     -10508.327      333.46943      333.46943      28090.328      28090.328     -974.40298     -974.40298    
Loop time of 102.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.578 hours/ns, 9.720 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.36     | 102.36     | 102.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079888   | 0.079888   | 0.079888   |   0.0 |  0.08
Output  | 0.0001658  | 0.0001658  | 0.0001658  |   0.0 |  0.00
Modify  | 0.38175    | 0.38175    | 0.38175    |   0.0 |  0.37
Other   |            | 0.05843    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3158 ave        3158 max        3158 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:       118968 ave      118968 max      118968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118968
Ave neighs/atom = 59.484
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 = 331.98977942597, Press = -1.64655899975162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10422.162     -10422.162     -10508.327     -10508.327      333.46943      333.46943      28090.328      28090.328     -974.40298     -974.40298    
     10000  -10422.364     -10422.364     -10508.756     -10508.756      334.34648      334.34648      28070.905      28070.905      185.19428      185.19428    
Loop time of 104.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.000 hours/ns, 9.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.87     | 103.87     | 103.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079965   | 0.079965   | 0.079965   |   0.0 |  0.08
Output  | 0.00016508 | 0.00016508 | 0.00016508 |   0.0 |  0.00
Modify  | 0.39191    | 0.39191    | 0.39191    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 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:       118984 ave      118984 max      118984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118984
Ave neighs/atom = 59.492
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 = 332.785035435582, Press = 0.441479759320861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10422.364     -10422.364     -10508.756     -10508.756      334.34648      334.34648      28070.905      28070.905      185.19428      185.19428    
     11000  -10425.437     -10425.437     -10509.487     -10509.487      325.28346      325.28346      28042.242      28042.242      1348.933       1348.933     
Loop time of 104.257 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.73     | 103.73     | 103.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079706   | 0.079706   | 0.079706   |   0.0 |  0.08
Output  | 0.00022445 | 0.00022445 | 0.00022445 |   0.0 |  0.00
Modify  | 0.38903    | 0.38903    | 0.38903    |   0.0 |  0.37
Other   |            | 0.05902    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3124 ave        3124 max        3124 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:       119030 ave      119030 max      119030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119030
Ave neighs/atom = 59.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.777220571891, Press = 6.64681065958708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10425.437     -10425.437     -10509.487     -10509.487      325.28346      325.28346      28042.242      28042.242      1348.933       1348.933     
     12000  -10422.037     -10422.037     -10508.011     -10508.011      332.72786      332.72786      28023.723      28023.723      2646.4083      2646.4083    
Loop time of 103.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.797 hours/ns, 9.646 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.14     | 103.14     | 103.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079682   | 0.079682   | 0.079682   |   0.0 |  0.08
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.38675    | 0.38675    | 0.38675    |   0.0 |  0.37
Other   |            | 0.05845    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3101 ave        3101 max        3101 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:       119168 ave      119168 max      119168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119168
Ave neighs/atom = 59.584
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 = 332.670303068566, Press = 3.27211816601078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10422.037     -10422.037     -10508.011     -10508.011      332.72786      332.72786      28023.723      28023.723      2646.4083      2646.4083    
     13000  -10426.944     -10426.944     -10507.466     -10507.466      311.62706      311.62706      28017.086      28017.086      2857.2732      2857.2732    
Loop time of 105.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.385 hours/ns, 9.453 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082189   | 0.082189   | 0.082189   |   0.0 |  0.08
Output  | 0.00016345 | 0.00016345 | 0.00016345 |   0.0 |  0.00
Modify  | 0.39874    | 0.39874    | 0.39874    |   0.0 |  0.38
Other   |            | 0.05913    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3156 ave        3156 max        3156 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:       119232 ave      119232 max      119232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119232
Ave neighs/atom = 59.616
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.374474584176, Press = -0.992339618325364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10426.944     -10426.944     -10507.466     -10507.466      311.62706      311.62706      28017.086      28017.086      2857.2732      2857.2732    
     14000  -10419.737     -10419.737     -10509.87      -10509.87       348.82258      348.82258      28037.011      28037.011      1794.7874      1794.7874    
Loop time of 103.008 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.613 hours/ns, 9.708 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.49     | 102.49     | 102.49     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079282   | 0.079282   | 0.079282   |   0.0 |  0.08
Output  | 0.00043337 | 0.00043337 | 0.00043337 |   0.0 |  0.00
Modify  | 0.38115    | 0.38115    | 0.38115    |   0.0 |  0.37
Other   |            | 0.05793    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 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:       119212 ave      119212 max      119212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119212
Ave neighs/atom = 59.606
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.390550161016, Press = -3.99552404864733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10419.737     -10419.737     -10509.87      -10509.87       348.82258      348.82258      28037.011      28037.011      1794.7874      1794.7874    
     15000  -10423.631     -10423.631     -10509.918     -10509.918      333.93912      333.93912      28031.861      28031.861      2074.2301      2074.2301    
Loop time of 104.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.119 hours/ns, 9.540 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080357   | 0.080357   | 0.080357   |   0.0 |  0.08
Output  | 0.00016533 | 0.00016533 | 0.00016533 |   0.0 |  0.00
Modify  | 0.39071    | 0.39071    | 0.39071    |   0.0 |  0.37
Other   |            | 0.05856    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 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:       119192 ave      119192 max      119192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119192
Ave neighs/atom = 59.596
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 = 332.634484996425, Press = -5.67583464930521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10423.631     -10423.631     -10509.918     -10509.918      333.93912      333.93912      28031.861      28031.861      2074.2301      2074.2301    
     16000  -10420.744     -10420.744     -10505.375     -10505.375      327.5297       327.5297       28047.119      28047.119      1517.6247      1517.6247    
Loop time of 106.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.543 hours/ns, 9.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.81     | 105.81     | 105.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082607   | 0.082607   | 0.082607   |   0.0 |  0.08
Output  | 0.00016885 | 0.00016885 | 0.00016885 |   0.0 |  0.00
Modify  | 0.39972    | 0.39972    | 0.39972    |   0.0 |  0.38
Other   |            | 0.05988    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3193 ave        3193 max        3193 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:       119126 ave      119126 max      119126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119126
Ave neighs/atom = 59.563
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 = 332.832501548456, Press = -6.57915117400915
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10420.744     -10420.744     -10505.375     -10505.375      327.5297       327.5297       28047.119      28047.119      1517.6247      1517.6247    
     17000  -10424.127     -10424.127     -10508.401     -10508.401      326.14896      326.14896      28063.208      28063.208      218.98199      218.98199    
Loop time of 103.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.820 hours/ns, 9.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.23     | 103.23     | 103.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080141   | 0.080141   | 0.080141   |   0.0 |  0.08
Output  | 0.00016473 | 0.00016473 | 0.00016473 |   0.0 |  0.00
Modify  | 0.38609    | 0.38609    | 0.38609    |   0.0 |  0.37
Other   |            | 0.05846    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 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:       119066 ave      119066 max      119066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119066
Ave neighs/atom = 59.533
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 = 332.892442406598, Press = -5.8119013974946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10424.127     -10424.127     -10508.401     -10508.401      326.14896      326.14896      28063.208      28063.208      218.98199      218.98199    
     18000  -10420.846     -10420.846     -10506.746     -10506.746      332.44035      332.44035      28078.924      28078.924     -281.53361     -281.53361    
Loop time of 106.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.481 hours/ns, 9.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.59     | 105.59     | 105.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082734   | 0.082734   | 0.082734   |   0.0 |  0.08
Output  | 0.00020573 | 0.00020573 | 0.00020573 |   0.0 |  0.00
Modify  | 0.3957     | 0.3957     | 0.3957     |   0.0 |  0.37
Other   |            | 0.05913    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3174 ave        3174 max        3174 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:       119106 ave      119106 max      119106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119106
Ave neighs/atom = 59.553
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 = 333.167044640983, Press = -5.28720903595611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10420.846     -10420.846     -10506.746     -10506.746      332.44035      332.44035      28078.924      28078.924     -281.53361     -281.53361    
     19000  -10420.884     -10420.884     -10508.502     -10508.502      339.09319      339.09319      28086.87       28086.87      -814.04543     -814.04543    
Loop time of 103.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.787 hours/ns, 9.649 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.11     | 103.11     | 103.11     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079424   | 0.079424   | 0.079424   |   0.0 |  0.08
Output  | 0.00016413 | 0.00016413 | 0.00016413 |   0.0 |  0.00
Modify  | 0.38264    | 0.38264    | 0.38264    |   0.0 |  0.37
Other   |            | 0.05849    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 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:       119090 ave      119090 max      119090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119090
Ave neighs/atom = 59.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.232249799812, Press = -4.70350090675692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10420.884     -10420.884     -10508.502     -10508.502      339.09319      339.09319      28086.87       28086.87      -814.04543     -814.04543    
     20000  -10429.362     -10429.362     -10512.228     -10512.228      320.70114      320.70114      28086.879      28086.879     -1449.2979     -1449.2979    
Loop time of 103.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.774 hours/ns, 9.654 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.06     | 103.06     | 103.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0799     | 0.0799     | 0.0799     |   0.0 |  0.08
Output  | 0.00024972 | 0.00024972 | 0.00024972 |   0.0 |  0.00
Modify  | 0.38628    | 0.38628    | 0.38628    |   0.0 |  0.37
Other   |            | 0.05894    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3158 ave        3158 max        3158 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:       119026 ave      119026 max      119026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119026
Ave neighs/atom = 59.513
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 = 333.105718477258, Press = -3.97648004866895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10429.362     -10429.362     -10512.228     -10512.228      320.70114      320.70114      28086.879      28086.879     -1449.2979     -1449.2979    
     21000  -10420.776     -10420.776     -10507.231     -10507.231      334.58926      334.58926      28135.287      28135.287     -3365.9624     -3365.9624    
Loop time of 106.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.675 hours/ns, 9.361 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.29     | 106.29     | 106.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081449   | 0.081449   | 0.081449   |   0.0 |  0.08
Output  | 0.00020077 | 0.00020077 | 0.00020077 |   0.0 |  0.00
Modify  | 0.40216    | 0.40216    | 0.40216    |   0.0 |  0.38
Other   |            | 0.05932    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 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:       119016 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508
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 = 332.962446025817, Press = -2.46830001503734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10420.776     -10420.776     -10507.231     -10507.231      334.58926      334.58926      28135.287      28135.287     -3365.9624     -3365.9624    
     22000  -10423.579     -10423.579     -10510.366     -10510.366      335.874        335.874        28117.361      28117.361     -2648.1672     -2648.1672    
Loop time of 104.058 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.905 hours/ns, 9.610 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.53     | 103.53     | 103.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07971    | 0.07971    | 0.07971    |   0.0 |  0.08
Output  | 0.00019832 | 0.00019832 | 0.00019832 |   0.0 |  0.00
Modify  | 0.38834    | 0.38834    | 0.38834    |   0.0 |  0.37
Other   |            | 0.0592     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3120 ave        3120 max        3120 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:       118956 ave      118956 max      118956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118956
Ave neighs/atom = 59.478
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 = 333.026205597217, Press = 0.204108785011654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10423.579     -10423.579     -10510.366     -10510.366      335.874        335.874        28117.361      28117.361     -2648.1672     -2648.1672    
     23000  -10418.412     -10418.412     -10505.512     -10505.512      337.08557      337.08557      28093.816      28093.816     -1055.3749     -1055.3749    
Loop time of 105.848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.402 hours/ns, 9.447 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.31     | 105.31     | 105.31     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080672   | 0.080672   | 0.080672   |   0.0 |  0.08
Output  | 0.0001973  | 0.0001973  | 0.0001973  |   0.0 |  0.00
Modify  | 0.39479    | 0.39479    | 0.39479    |   0.0 |  0.37
Other   |            | 0.05871    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3092 ave        3092 max        3092 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:       118934 ave      118934 max      118934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118934
Ave neighs/atom = 59.467
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
28070.5135050604

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0