# 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 5.431141197681427*${_u_distance}
variable latticeconst_converted equal 5.431141197681427*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.43114119768143
Lattice spacing in x,y,z = 5.4311412 5.4311412 5.4311412
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (54.311412 54.311412 54.311412)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0 0 0) to (54.311412 54.311412 54.311412)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Si

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

kim interactions Si
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_DuLenoskyHennig_2011_Si__MO_883726743759_002
pair_coeff * * Si
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 28.0855

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 16 16 16
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.657 | 8.657 | 8.657 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -36762.635     -36762.635     -37045.059     -37045.059      273.15         273.15         160203.97      160203.97      1883           1883         
      1000  -36445.314     -36445.314     -36740.079     -36740.079      285.08634      285.08634      159589.87      159589.87     -605.0452      -605.0452     
Loop time of 571.157 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 158.655 hours/ns, 1.751 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    | 569.35     | 569.35     | 569.35     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2554     | 0.2554     | 0.2554     |   0.0 |  0.04
Output  | 0.0002868  | 0.0002868  | 0.0002868  |   0.0 |  0.00
Modify  | 1.386      | 1.386      | 1.386      |   0.0 |  0.24
Other   |            | 0.1699     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       688000 ave      688000 max      688000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 688000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -36445.314     -36445.314     -36740.079     -36740.079      285.08634      285.08634      159589.87      159589.87     -605.0452      -605.0452     
      2000  -36479.002     -36479.002     -36753.508     -36753.508      265.49208      265.49208      159359.86      159359.86      658.01715      658.01715    
Loop time of 584.006 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.224 hours/ns, 1.712 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    | 582.15     | 582.15     | 582.15     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25475    | 0.25475    | 0.25475    |   0.0 |  0.04
Output  | 0.00027543 | 0.00027543 | 0.00027543 |   0.0 |  0.00
Modify  | 1.4315     | 1.4315     | 1.4315     |   0.0 |  0.25
Other   |            | 0.173      |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685402 ave      685402 max      685402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685402
Ave neighs/atom = 85.67525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -36479.002     -36479.002     -36753.508     -36753.508      265.49208      265.49208      159359.86      159359.86      658.01715      658.01715    
      3000  -36459.104     -36459.104     -36750.68      -36750.68       282.00188      282.00188      159445.92      159445.92      7.9049132      7.9049132    
Loop time of 590.155 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.146 ns/day, 163.932 hours/ns, 1.694 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    | 588.25     | 588.25     | 588.25     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25843    | 0.25843    | 0.25843    |   0.0 |  0.04
Output  | 0.00031814 | 0.00031814 | 0.00031814 |   0.0 |  0.00
Modify  | 1.471      | 1.471      | 1.471      |   0.0 |  0.25
Other   |            | 0.1756     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686016 ave      686016 max      686016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686016
Ave neighs/atom = 85.752
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -36459.104     -36459.104     -36750.68      -36750.68       282.00188      282.00188      159445.92      159445.92      7.9049132      7.9049132    
      4000  -36471.613     -36471.613     -36754.568     -36754.568      273.66334      273.66334      159309.83      159309.83      956.55396      956.55396    
Loop time of 588.694 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.526 hours/ns, 1.699 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    | 586.79     | 586.79     | 586.79     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25842    | 0.25842    | 0.25842    |   0.0 |  0.04
Output  | 0.00032612 | 0.00032612 | 0.00032612 |   0.0 |  0.00
Modify  | 1.4717     | 1.4717     | 1.4717     |   0.0 |  0.25
Other   |            | 0.1764     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685494 ave      685494 max      685494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685494
Ave neighs/atom = 85.68675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -36471.613     -36471.613     -36754.568     -36754.568      273.66334      273.66334      159309.83      159309.83      956.55396      956.55396    
      5000  -36464.409     -36464.409     -36748.983     -36748.983      275.2301       275.2301       159343.05      159343.05      835.66642      835.66642    
Loop time of 585.006 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.502 hours/ns, 1.709 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    | 583.12     | 583.12     | 583.12     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2571     | 0.2571     | 0.2571     |   0.0 |  0.04
Output  | 0.00023511 | 0.00023511 | 0.00023511 |   0.0 |  0.00
Modify  | 1.458      | 1.458      | 1.458      |   0.0 |  0.25
Other   |            | 0.1744     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       686018 ave      686018 max      686018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 686018
Ave neighs/atom = 85.75225
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 = 274.88797529864, Press = 76.9412269836056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -36464.409     -36464.409     -36748.983     -36748.983      275.2301       275.2301       159343.05      159343.05      835.66642      835.66642    
      6000  -36467.499     -36467.499     -36747.418     -36747.418      270.72728      270.72728      159464.5       159464.5       112.49724      112.49724    
Loop time of 584.685 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.413 hours/ns, 1.710 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 582.77     | 582.77     | 582.77     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25634    | 0.25634    | 0.25634    |   0.0 |  0.04
Output  | 0.00023799 | 0.00023799 | 0.00023799 |   0.0 |  0.00
Modify  | 1.4878     | 1.4878     | 1.4878     |   0.0 |  0.25
Other   |            | 0.1746     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685772 ave      685772 max      685772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685772
Ave neighs/atom = 85.7215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.850213830451, Press = -8.43052961337615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -36467.499     -36467.499     -36747.418     -36747.418      270.72728      270.72728      159464.5       159464.5       112.49724      112.49724    
      7000  -36466.948     -36466.948     -36750.056     -36750.056      273.81208      273.81208      159324.07      159324.07      658.88407      658.88407    
Loop time of 585.422 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.617 hours/ns, 1.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    | 583.5      | 583.5      | 583.5      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25675    | 0.25675    | 0.25675    |   0.0 |  0.04
Output  | 0.00024112 | 0.00024112 | 0.00024112 |   0.0 |  0.00
Modify  | 1.4884     | 1.4884     | 1.4884     |   0.0 |  0.25
Other   |            | 0.1742     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685480 ave      685480 max      685480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685480
Ave neighs/atom = 85.685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.178982261056, Press = 11.77257555409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -36466.948     -36466.948     -36750.056     -36750.056      273.81208      273.81208      159324.07      159324.07      658.88407      658.88407    
      8000  -36466.614     -36466.614     -36748.182     -36748.182      272.32222      272.32222      159403.9       159403.9       204.32224      204.32224    
Loop time of 582.477 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.799 hours/ns, 1.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.59     | 580.59     | 580.59     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25412    | 0.25412    | 0.25412    |   0.0 |  0.04
Output  | 0.00023539 | 0.00023539 | 0.00023539 |   0.0 |  0.00
Modify  | 1.4639     | 1.4639     | 1.4639     |   0.0 |  0.25
Other   |            | 0.1724     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685804 ave      685804 max      685804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685804
Ave neighs/atom = 85.7255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.086324110486, Press = 2.302636419719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -36466.614     -36466.614     -36748.182     -36748.182      272.32222      272.32222      159403.9       159403.9       204.32224      204.32224    
      9000  -36467.957     -36467.957     -36753.028     -36753.028      275.71045      275.71045      159288.65      159288.65      944.28112      944.28112    
Loop time of 582.763 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.879 hours/ns, 1.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.86     | 580.86     | 580.86     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25519    | 0.25519    | 0.25519    |   0.0 |  0.04
Output  | 0.00023176 | 0.00023176 | 0.00023176 |   0.0 |  0.00
Modify  | 1.4741     | 1.4741     | 1.4741     |   0.0 |  0.25
Other   |            | 0.1732     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685496 ave      685496 max      685496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685496
Ave neighs/atom = 85.687
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.190146726563, Press = -0.851154480037526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -36467.957     -36467.957     -36753.028     -36753.028      275.71045      275.71045      159288.65      159288.65      944.28112      944.28112    
     10000  -36463.828     -36463.828     -36746.61      -36746.61       273.49654      273.49654      159399.07      159399.07      152.17654      152.17654    
Loop time of 582.095 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.693 hours/ns, 1.718 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.21     | 580.21     | 580.21     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25258    | 0.25258    | 0.25258    |   0.0 |  0.04
Output  | 0.00028729 | 0.00028729 | 0.00028729 |   0.0 |  0.00
Modify  | 1.4577     | 1.4577     | 1.4577     |   0.0 |  0.25
Other   |            | 0.1717     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685870 ave      685870 max      685870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685870
Ave neighs/atom = 85.73375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.109334453499, Press = 0.449300817423907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -36463.828     -36463.828     -36746.61      -36746.61       273.49654      273.49654      159399.07      159399.07      152.17654      152.17654    
     11000  -36469.185     -36469.185     -36749.569     -36749.569      271.17753      271.17753      159453.45      159453.45     -62.58814      -62.58814     
Loop time of 578.762 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.767 hours/ns, 1.728 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    | 576.89     | 576.89     | 576.89     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25308    | 0.25308    | 0.25308    |   0.0 |  0.04
Output  | 0.00024343 | 0.00024343 | 0.00024343 |   0.0 |  0.00
Modify  | 1.4476     | 1.4476     | 1.4476     |   0.0 |  0.25
Other   |            | 0.1714     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685606 ave      685606 max      685606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685606
Ave neighs/atom = 85.70075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.171068669839, Press = -3.18569762611591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -36469.185     -36469.185     -36749.569     -36749.569      271.17753      271.17753      159453.45      159453.45     -62.58814      -62.58814     
     12000  -36464.229     -36464.229     -36750.897     -36750.897      277.25494      277.25494      159461.44      159461.44     -137.51065     -137.51065    
Loop time of 587.172 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.103 hours/ns, 1.703 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    | 585.25     | 585.25     | 585.25     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25711    | 0.25711    | 0.25711    |   0.0 |  0.04
Output  | 0.00023604 | 0.00023604 | 0.00023604 |   0.0 |  0.00
Modify  | 1.4908     | 1.4908     | 1.4908     |   0.0 |  0.25
Other   |            | 0.1751     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685650 ave      685650 max      685650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685650
Ave neighs/atom = 85.70625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.34062936461, Press = 1.84787354233316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -36464.229     -36464.229     -36750.897     -36750.897      277.25494      277.25494      159461.44      159461.44     -137.51065     -137.51065    
     13000  -36462.249     -36462.249     -36743.445     -36743.445      271.96206      271.96206      159213.67      159213.67      944.84405      944.84405    
Loop time of 582.826 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.896 hours/ns, 1.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 580.94     | 580.94     | 580.94     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25324    | 0.25324    | 0.25324    |   0.0 |  0.04
Output  | 0.00030347 | 0.00030347 | 0.00030347 |   0.0 |  0.00
Modify  | 1.4569     | 1.4569     | 1.4569     |   0.0 |  0.25
Other   |            | 0.1736     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685596 ave      685596 max      685596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685596
Ave neighs/atom = 85.6995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.340988314818, Press = -2.31871076124245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -36462.249     -36462.249     -36743.445     -36743.445      271.96206      271.96206      159213.67      159213.67      944.84405      944.84405    
     14000  -36465.521     -36465.521     -36749.223     -36749.223      274.38596      274.38596      159441.8       159441.8      -3.1222224     -3.1222224    
Loop time of 582.907 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.919 hours/ns, 1.716 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    | 581.01     | 581.01     | 581.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25415    | 0.25415    | 0.25415    |   0.0 |  0.04
Output  | 0.00030344 | 0.00030344 | 0.00030344 |   0.0 |  0.00
Modify  | 1.4739     | 1.4739     | 1.4739     |   0.0 |  0.25
Other   |            | 0.1725     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685522 ave      685522 max      685522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685522
Ave neighs/atom = 85.69025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.497155892284, Press = -1.33644563412498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -36465.521     -36465.521     -36749.223     -36749.223      274.38596      274.38596      159441.8       159441.8      -3.1222224     -3.1222224    
     15000  -36469.977     -36469.977     -36751.492     -36751.492      272.27056      272.27056      159470.9       159470.9      -237.50525     -237.50525    
Loop time of 577.285 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 160.357 hours/ns, 1.732 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    | 575.42     | 575.42     | 575.42     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25317    | 0.25317    | 0.25317    |   0.0 |  0.04
Output  | 0.00025627 | 0.00025627 | 0.00025627 |   0.0 |  0.00
Modify  | 1.4418     | 1.4418     | 1.4418     |   0.0 |  0.25
Other   |            | 0.1711     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685640 ave      685640 max      685640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685640
Ave neighs/atom = 85.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.488422325046, Press = 1.62322227517821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -36469.977     -36469.977     -36751.492     -36751.492      272.27056      272.27056      159470.9       159470.9      -237.50525     -237.50525    
     16000  -36463.333     -36463.333     -36747.203     -36747.203      274.54808      274.54808      159312.17      159312.17      448.43633      448.43633    
Loop time of 578.535 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.704 hours/ns, 1.729 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    | 576.67     | 576.67     | 576.67     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25049    | 0.25049    | 0.25049    |   0.0 |  0.04
Output  | 0.00023092 | 0.00023092 | 0.00023092 |   0.0 |  0.00
Modify  | 1.4423     | 1.4423     | 1.4423     |   0.0 |  0.25
Other   |            | 0.1714     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685570 ave      685570 max      685570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685570
Ave neighs/atom = 85.69625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45014410233, Press = -0.161985754571852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -36463.333     -36463.333     -36747.203     -36747.203      274.54808      274.54808      159312.17      159312.17      448.43633      448.43633    
     17000  -36468.498     -36468.498     -36751.992     -36751.992      274.1848       274.1848       159356.52      159356.52      388.33792      388.33792    
Loop time of 583.85 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 162.181 hours/ns, 1.713 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    | 581.95     | 581.95     | 581.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25396    | 0.25396    | 0.25396    |   0.0 |  0.04
Output  | 0.00023529 | 0.00023529 | 0.00023529 |   0.0 |  0.00
Modify  | 1.4764     | 1.4764     | 1.4764     |   0.0 |  0.25
Other   |            | 0.1736     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685478 ave      685478 max      685478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685478
Ave neighs/atom = 85.68475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.514967904035, Press = -0.759780760467089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -36468.498     -36468.498     -36751.992     -36751.992      274.1848       274.1848       159356.52      159356.52      388.33792      388.33792    
     18000  -36463.197     -36463.197     -36745.507     -36745.507      273.03931      273.03931      159353.11      159353.11      107.37926      107.37926    
Loop time of 581.99 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.148 ns/day, 161.664 hours/ns, 1.718 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    | 580.1      | 580.1      | 580.1      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2552     | 0.2552     | 0.2552     |   0.0 |  0.04
Output  | 0.0002757  | 0.0002757  | 0.0002757  |   0.0 |  0.00
Modify  | 1.4615     | 1.4615     | 1.4615     |   0.0 |  0.25
Other   |            | 0.1714     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685642 ave      685642 max      685642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685642
Ave neighs/atom = 85.70525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.524232742119, Press = 0.232790271984583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -36463.197     -36463.197     -36745.507     -36745.507      273.03931      273.03931      159353.11      159353.11      107.37926      107.37926    
     19000  -36467.739     -36467.739     -36744.378     -36744.378      267.55513      267.55513      159464.56      159464.56     -447.3218      -447.3218     
Loop time of 579.613 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 161.004 hours/ns, 1.725 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    | 577.74     | 577.74     | 577.74     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25198    | 0.25198    | 0.25198    |   0.0 |  0.04
Output  | 0.00023465 | 0.00023465 | 0.00023465 |   0.0 |  0.00
Modify  | 1.4538     | 1.4538     | 1.4538     |   0.0 |  0.25
Other   |            | 0.1719     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685468 ave      685468 max      685468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685468
Ave neighs/atom = 85.6835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.485758032791, Press = -0.872988012383458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -36467.739     -36467.739     -36744.378     -36744.378      267.55513      267.55513      159464.56      159464.56     -447.3218      -447.3218     
     20000  -36466.155     -36466.155     -36748.833     -36748.833      273.39566      273.39566      159449.29      159449.29     -209.84638     -209.84638    
Loop time of 586.244 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 162.846 hours/ns, 1.706 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    | 584.33     | 584.33     | 584.33     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25625    | 0.25625    | 0.25625    |   0.0 |  0.04
Output  | 0.00035082 | 0.00035082 | 0.00035082 |   0.0 |  0.00
Modify  | 1.4841     | 1.4841     | 1.4841     |   0.0 |  0.25
Other   |            | 0.1735     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685396 ave      685396 max      685396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685396
Ave neighs/atom = 85.6745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.405494184146, Press = -0.689206647369342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -36466.155     -36466.155     -36748.833     -36748.833      273.39566      273.39566      159449.29      159449.29     -209.84638     -209.84638    
     21000  -36463.036     -36463.036     -36748.254     -36748.254      275.85306      275.85306      159434.1       159434.1      -284.71703     -284.71703    
Loop time of 587.229 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.119 hours/ns, 1.703 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    | 585.31     | 585.31     | 585.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25733    | 0.25733    | 0.25733    |   0.0 |  0.04
Output  | 0.00023913 | 0.00023913 | 0.00023913 |   0.0 |  0.00
Modify  | 1.4862     | 1.4862     | 1.4862     |   0.0 |  0.25
Other   |            | 0.1738     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685418 ave      685418 max      685418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685418
Ave neighs/atom = 85.67725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.391929177963, Press = -0.351990213438098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -36463.036     -36463.036     -36748.254     -36748.254      275.85306      275.85306      159434.1       159434.1      -284.71703     -284.71703    
     22000  -36467.27      -36467.27      -36750.283     -36750.283      273.71973      273.71973      159336.47      159336.47      516.01405      516.01405    
Loop time of 589.659 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.794 hours/ns, 1.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 587.72     | 587.72     | 587.72     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25795    | 0.25795    | 0.25795    |   0.0 |  0.04
Output  | 0.00023768 | 0.00023768 | 0.00023768 |   0.0 |  0.00
Modify  | 1.5013     | 1.5013     | 1.5013     |   0.0 |  0.25
Other   |            | 0.1756     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685344 ave      685344 max      685344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685344
Ave neighs/atom = 85.668
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.393816022068, Press = 0.816529790964786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -36467.27      -36467.27      -36750.283     -36750.283      273.71973      273.71973      159336.47      159336.47      516.01405      516.01405    
     23000  -36479.08      -36479.08      -36754.533     -36754.533      266.40847      266.40847      159366.3       159366.3       332.16257      332.16257    
Loop time of 588.299 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.416 hours/ns, 1.700 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 586.38     | 586.38     | 586.38     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25648    | 0.25648    | 0.25648    |   0.0 |  0.04
Output  | 0.0002908  | 0.0002908  | 0.0002908  |   0.0 |  0.00
Modify  | 1.4913     | 1.4913     | 1.4913     |   0.0 |  0.25
Other   |            | 0.1748     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685602 ave      685602 max      685602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685602
Ave neighs/atom = 85.70025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.303697755429, Press = -0.522115469563139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -36479.08      -36479.08      -36754.533     -36754.533      266.40847      266.40847      159366.3       159366.3       332.16257      332.16257    
     24000  -36466.064     -36466.064     -36749.32      -36749.32       273.95449      273.95449      159544.55      159544.55     -568.85454     -568.85454    
Loop time of 588.355 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.432 hours/ns, 1.700 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    | 586.41     | 586.41     | 586.41     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2573     | 0.2573     | 0.2573     |   0.0 |  0.04
Output  | 0.00028171 | 0.00028171 | 0.00028171 |   0.0 |  0.00
Modify  | 1.5096     | 1.5096     | 1.5096     |   0.0 |  0.26
Other   |            | 0.1761     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685686 ave      685686 max      685686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685686
Ave neighs/atom = 85.71075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.254187375547, Press = -1.14010015520659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -36466.064     -36466.064     -36749.32      -36749.32       273.95449      273.95449      159544.55      159544.55     -568.85454     -568.85454    
     25000  -36472.415     -36472.415     -36751.136     -36751.136      269.56876      269.56876      159504.29      159504.29     -295.12381     -295.12381    
Loop time of 590.023 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.146 ns/day, 163.895 hours/ns, 1.695 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 588.1      | 588.1      | 588.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25497    | 0.25497    | 0.25497    |   0.0 |  0.04
Output  | 0.00023722 | 0.00023722 | 0.00023722 |   0.0 |  0.00
Modify  | 1.4954     | 1.4954     | 1.4954     |   0.0 |  0.25
Other   |            | 0.1755     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685508 ave      685508 max      685508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685508
Ave neighs/atom = 85.6885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.21640149531, Press = 0.865181611217957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -36472.415     -36472.415     -36751.136     -36751.136      269.56876      269.56876      159504.29      159504.29     -295.12381     -295.12381    
     26000  -36467.649     -36467.649     -36746.693     -36746.693      269.88125      269.88125      159313.59      159313.59      484.95754      484.95754    
Loop time of 579.263 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.149 ns/day, 160.906 hours/ns, 1.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 577.37     | 577.37     | 577.37     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25317    | 0.25317    | 0.25317    |   0.0 |  0.04
Output  | 0.00024252 | 0.00024252 | 0.00024252 |   0.0 |  0.00
Modify  | 1.4637     | 1.4637     | 1.4637     |   0.0 |  0.25
Other   |            | 0.1734     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685520 ave      685520 max      685520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685520
Ave neighs/atom = 85.69
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.197108132019, Press = -0.652350935325696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -36467.649     -36467.649     -36746.693     -36746.693      269.88125      269.88125      159313.59      159313.59      484.95754      484.95754    
     27000  -36466.21      -36466.21      -36751.76      -36751.76       276.17366      276.17366      159468.04      159468.04     -39.189131     -39.189131    
Loop time of 575.704 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.150 ns/day, 159.918 hours/ns, 1.737 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 573.84     | 573.84     | 573.84     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25043    | 0.25043    | 0.25043    |   0.0 |  0.04
Output  | 0.00023663 | 0.00023663 | 0.00023663 |   0.0 |  0.00
Modify  | 1.4391     | 1.4391     | 1.4391     |   0.0 |  0.25
Other   |            | 0.1719     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685662 ave      685662 max      685662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685662
Ave neighs/atom = 85.70775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.13127403943, Press = -1.62042898096182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -36466.21      -36466.21      -36751.76      -36751.76       276.17366      276.17366      159468.04      159468.04     -39.189131     -39.189131    
     28000  -36471.061     -36471.061     -36753.002     -36753.002      272.68311      272.68311      159636.49      159636.49     -864.44456     -864.44456    
Loop time of 586.653 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 162.959 hours/ns, 1.705 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 584.73     | 584.73     | 584.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25512    | 0.25512    | 0.25512    |   0.0 |  0.04
Output  | 0.00023907 | 0.00023907 | 0.00023907 |   0.0 |  0.00
Modify  | 1.4934     | 1.4934     | 1.4934     |   0.0 |  0.25
Other   |            | 0.1752     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685710 ave      685710 max      685710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685710
Ave neighs/atom = 85.71375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.125570919593, Press = 0.430756318326492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -36471.061     -36471.061     -36753.002     -36753.002      272.68311      272.68311      159636.49      159636.49     -864.44456     -864.44456    
     29000  -36465.886     -36465.886     -36748.515     -36748.515      273.34845      273.34845      159447.48      159447.48     -29.365595     -29.365595    
Loop time of 586.976 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.147 ns/day, 163.049 hours/ns, 1.704 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 585.07     | 585.07     | 585.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25568    | 0.25568    | 0.25568    |   0.0 |  0.04
Output  | 0.00023325 | 0.00023325 | 0.00023325 |   0.0 |  0.00
Modify  | 1.4797     | 1.4797     | 1.4797     |   0.0 |  0.25
Other   |            | 0.1738     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685396 ave      685396 max      685396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 685396
Ave neighs/atom = 85.6745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.164125268155, Press = 0.973920735174254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.24
  ghost atom cutoff = 7.24
  binsize = 3.62, bins = 15 15 15
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.24
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 8.522 | 8.522 | 8.522 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -36465.886     -36465.886     -36748.515     -36748.515      273.34845      273.34845      159447.48      159447.48     -29.365595     -29.365595    
     30000  -36462.596     -36462.596     -36747.352     -36747.352      275.40511      275.40511      159425.03      159425.03      11.596631      11.596631    
Loop time of 574.063 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.151 ns/day, 159.462 hours/ns, 1.742 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 572.2      | 572.2      | 572.2      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.25114    | 0.25114    | 0.25114    |   0.0 |  0.04
Output  | 0.00023641 | 0.00023641 | 0.00023641 |   0.0 |  0.00
Modify  | 1.4375     | 1.4375     | 1.4375     |   0.0 |  0.25
Other   |            | 0.1698     |            |       |  0.03

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8601 ave        8601 max        8601 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:       685612 ave      685612 max      685612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0