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

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoShimLee_2011_NiH__MO_091278480940_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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_091278480940_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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.961      43665.961      3453.7839      3453.7839    
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3467     -1595.3467    
Loop time of 50.1597 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.722 ns/day, 13.933 hours/ns, 19.936 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 50.008     | 50.008     | 50.008     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022212   | 0.022212   | 0.022212   |   0.0 |  0.04
Output  | 0.00014093 | 0.00014093 | 0.00014093 |   0.0 |  0.00
Modify  | 0.11906    | 0.11906    | 0.11906    |   0.0 |  0.24
Other   |            | 0.01059    |            |       |  0.02

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

Total # of neighbors = 312000
Ave neighs/atom = 78
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3467     -1595.3467    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.45504      513.45504    
Loop time of 57.4097 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.505 ns/day, 15.947 hours/ns, 17.419 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.26      | 57.26      | 57.26      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.04
Output  | 4.6738e-05 | 4.6738e-05 | 4.6738e-05 |   0.0 |  0.00
Modify  | 0.11752    | 0.11752    | 0.11752    |   0.0 |  0.20
Other   |            | 0.01026    |            |       |  0.02

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

Total # of neighbors = 313692
Ave neighs/atom = 78.423
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.45504      513.45504    
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78575      359.78575    
Loop time of 57.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.498 ns/day, 16.020 hours/ns, 17.339 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.522     | 57.522     | 57.522     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0218     | 0.0218     | 0.0218     |   0.0 |  0.04
Output  | 4.3653e-05 | 4.3653e-05 | 4.3653e-05 |   0.0 |  0.00
Modify  | 0.11748    | 0.11748    | 0.11748    |   0.0 |  0.20
Other   |            | 0.01017    |            |       |  0.02

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

Total # of neighbors = 313914
Ave neighs/atom = 78.4785
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78575      359.78575    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.664597     -41.664597    
Loop time of 57.7688 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.047 hours/ns, 17.310 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.619     | 57.619     | 57.619     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021668   | 0.021668   | 0.021668   |   0.0 |  0.04
Output  | 4.4043e-05 | 4.4043e-05 | 4.4043e-05 |   0.0 |  0.00
Modify  | 0.11743    | 0.11743    | 0.11743    |   0.0 |  0.20
Other   |            | 0.01019    |            |       |  0.02

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

Total # of neighbors = 313942
Ave neighs/atom = 78.4855
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.664597     -41.664597    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97874     -295.97874    
Loop time of 57.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.497 ns/day, 16.030 hours/ns, 17.328 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.559     | 57.559     | 57.559     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021688   | 0.021688   | 0.021688   |   0.0 |  0.04
Output  | 3.6299e-05 | 3.6299e-05 | 3.6299e-05 |   0.0 |  0.00
Modify  | 0.1178     | 0.1178     | 0.1178     |   0.0 |  0.20
Other   |            | 0.01022    |            |       |  0.02

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

Total # of neighbors = 313854
Ave neighs/atom = 78.4635
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 = 270.611136067679, Press = -333.668789490264
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97874     -295.97874    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4793      2027.4793    
Loop time of 57.7766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.495 ns/day, 16.049 hours/ns, 17.308 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.623     | 57.623     | 57.623     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02167    | 0.02167    | 0.02167    |   0.0 |  0.04
Output  | 3.6208e-05 | 3.6208e-05 | 3.6208e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.21
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 313804
Ave neighs/atom = 78.451
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.788199622969, Press = 6.19617746541555
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4793      2027.4793    
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9727     -2174.9727    
Loop time of 57.8233 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.062 hours/ns, 17.294 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.67      | 57.67      | 57.67      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0218     | 0.0218     | 0.0218     |   0.0 |  0.04
Output  | 3.5597e-05 | 3.5597e-05 | 3.5597e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.21
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 314060
Ave neighs/atom = 78.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 = 273.017667461471, Press = 7.4225075888593
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9727     -2174.9727    
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30626     -104.30626    
Loop time of 57.7062 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.497 ns/day, 16.029 hours/ns, 17.329 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.553     | 57.553     | 57.553     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021597   | 0.021597   | 0.021597   |   0.0 |  0.04
Output  | 3.6088e-05 | 3.6088e-05 | 3.6088e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 313778
Ave neighs/atom = 78.4445
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.964957614613, Press = -22.1650930774426
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30626     -104.30626    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80965      271.80965      44081.577      44081.577      584.35344      584.35344    
Loop time of 57.756 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.043 hours/ns, 17.314 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.603     | 57.603     | 57.603     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.04
Output  | 3.5647e-05 | 3.5647e-05 | 3.5647e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 313732
Ave neighs/atom = 78.433
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.602525308007, Press = 1.69507515286412
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80965      271.80965      44081.577      44081.577      584.35344      584.35344    
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18345      278.18345      44139.015      44139.015     -1088.1294     -1088.1294    
Loop time of 57.8088 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.495 ns/day, 16.058 hours/ns, 17.298 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.656     | 57.656     | 57.656     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.04
Output  | 3.4445e-05 | 3.4445e-05 | 3.4445e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 313794
Ave neighs/atom = 78.4485
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.920793401586, Press = -2.82756535591628
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18345      278.18345      44139.015      44139.015     -1088.1294     -1088.1294    
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17785      265.17785      44083.794      44083.794      857.98891      857.98891    
Loop time of 57.9014 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.084 hours/ns, 17.271 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.748     | 57.748     | 57.748     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021684   | 0.021684   | 0.021684   |   0.0 |  0.04
Output  | 2.8684e-05 | 2.8684e-05 | 2.8684e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.21
Other   |            | 0.01025    |            |       |  0.02

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

Total # of neighbors = 313740
Ave neighs/atom = 78.435
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.111360594062, Press = -5.0688825434167
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17785      265.17785      44083.794      44083.794      857.98891      857.98891    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93849      272.93849      44077.693      44077.693      626.52294      626.52294    
Loop time of 57.848 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.069 hours/ns, 17.287 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.695     | 57.695     | 57.695     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021642   | 0.021642   | 0.021642   |   0.0 |  0.04
Output  | 2.8894e-05 | 2.8894e-05 | 2.8894e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.21
Other   |            | 0.01021    |            |       |  0.02

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

Total # of neighbors = 313876
Ave neighs/atom = 78.469
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.170097886508, Press = 6.06937368779868
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93849      272.93849      44077.693      44077.693      626.52294      626.52294    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69305      277.69305      44168.987      44168.987     -2879.6145     -2879.6145    
Loop time of 57.7696 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.047 hours/ns, 17.310 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.616     | 57.616     | 57.616     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021728   | 0.021728   | 0.021728   |   0.0 |  0.04
Output  | 3.8052e-05 | 3.8052e-05 | 3.8052e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.21
Other   |            | 0.01027    |            |       |  0.02

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

Total # of neighbors = 313796
Ave neighs/atom = 78.449
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.041612279863, Press = -4.17412841908287
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69305      277.69305      44168.987      44168.987     -2879.6145     -2879.6145    
     14000  -17520.901     -17520.901     -17661.44      -17661.44       271.8836       271.8836       44067.126      44067.126      971.66706      971.66706    
Loop time of 57.7471 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.041 hours/ns, 17.317 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.594     | 57.594     | 57.594     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021618   | 0.021618   | 0.021618   |   0.0 |  0.04
Output  | 6.0293e-05 | 6.0293e-05 | 6.0293e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01028    |            |       |  0.02

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

Total # of neighbors = 313650
Ave neighs/atom = 78.4125
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.838286511609, Press = -4.4297047811557
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17520.901     -17520.901     -17661.44      -17661.44       271.8836       271.8836       44067.126      44067.126      971.66706      971.66706    
     15000  -17517.76      -17517.76      -17657.375     -17657.375      270.09615      270.09615      44096.825      44096.825      151.90687      151.90687    
Loop time of 57.8332 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.065 hours/ns, 17.291 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.68      | 57.68      | 57.68      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021613   | 0.021613   | 0.021613   |   0.0 |  0.04
Output  | 3.7781e-05 | 3.7781e-05 | 3.7781e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.21
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 313742
Ave neighs/atom = 78.4355
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.824923862403, Press = 1.52589211930999
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17517.76      -17517.76      -17657.375     -17657.375      270.09615      270.09615      44096.825      44096.825      151.90687      151.90687    
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.4691       279.4691       44126.699      44126.699     -1048.809      -1048.809     
Loop time of 57.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.079 hours/ns, 17.275 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.732     | 57.732     | 57.732     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021851   | 0.021851   | 0.021851   |   0.0 |  0.04
Output  | 3.7521e-05 | 3.7521e-05 | 3.7521e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.21
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453
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.76689790124, Press = -2.13168307932296
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.4691       279.4691       44126.699      44126.699     -1048.809      -1048.809     
     17000  -17520.535     -17520.535     -17660.336     -17660.336      270.45626      270.45626      44076.721      44076.721      638.3887       638.3887     
Loop time of 57.8202 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.061 hours/ns, 17.295 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.667     | 57.667     | 57.667     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021743   | 0.021743   | 0.021743   |   0.0 |  0.04
Output  | 3.7039e-05 | 3.7039e-05 | 3.7039e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.21
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 313638
Ave neighs/atom = 78.4095
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.733403814057, Press = -2.64208325842267
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17520.535     -17520.535     -17660.336     -17660.336      270.45626      270.45626      44076.721      44076.721      638.3887       638.3887     
     18000  -17514.937     -17514.937     -17657.561     -17657.561      275.91428      275.91428      44070.081      44070.081      1203.1522      1203.1522    
Loop time of 57.8494 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.069 hours/ns, 17.286 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.696     | 57.696     | 57.696     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021728   | 0.021728   | 0.021728   |   0.0 |  0.04
Output  | 3.693e-05  | 3.693e-05  | 3.693e-05  |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.21
Other   |            | 0.01035    |            |       |  0.02

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

Total # of neighbors = 313840
Ave neighs/atom = 78.46
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.662610243662, Press = 3.64218788363971
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17514.937     -17514.937     -17657.561     -17657.561      275.91428      275.91428      44070.081      44070.081      1203.1522      1203.1522    
     19000  -17518.092     -17518.092     -17658.704     -17658.704      272.02323      272.02323      44151.325      44151.325     -2256.7228     -2256.7228    
Loop time of 57.911 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.086 hours/ns, 17.268 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.758     | 57.758     | 57.758     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021671   | 0.021671   | 0.021671   |   0.0 |  0.04
Output  | 3.8262e-05 | 3.8262e-05 | 3.8262e-05 |   0.0 |  0.00
Modify  | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.21
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 313900
Ave neighs/atom = 78.475
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.633059023776, Press = -2.1292266376441
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17518.092     -17518.092     -17658.704     -17658.704      272.02323      272.02323      44151.325      44151.325     -2256.7228     -2256.7228    
     20000  -17514.864     -17514.864     -17655.588     -17655.588      272.23851      272.23851      44073.67       44073.67       1307.0588      1307.0588    
Loop time of 57.7606 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.496 ns/day, 16.045 hours/ns, 17.313 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.607     | 57.607     | 57.607     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.04
Output  | 3.724e-05  | 3.724e-05  | 3.724e-05  |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.21
Other   |            | 0.01024    |            |       |  0.02

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

Total # of neighbors = 313618
Ave neighs/atom = 78.4045
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.662097373083, Press = -1.98690338547308
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17514.864     -17514.864     -17655.588     -17655.588      272.23851      272.23851      44073.67       44073.67       1307.0588      1307.0588    
     21000  -17515.996     -17515.996     -17660.029     -17660.029      278.64198      278.64198      44104.894      44104.894     -388.72332     -388.72332    
Loop time of 57.9222 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.090 hours/ns, 17.265 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.768     | 57.768     | 57.768     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021776   | 0.021776   | 0.021776   |   0.0 |  0.04
Output  | 0.00010375 | 0.00010375 | 0.00010375 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.21
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 313932
Ave neighs/atom = 78.483
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.677777983191, Press = 1.31819642542428
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17515.996     -17515.996     -17660.029     -17660.029      278.64198      278.64198      44104.894      44104.894     -388.72332     -388.72332    
     22000  -17521.574     -17521.574     -17660.712     -17660.712      269.17125      269.17125      44110.705      44110.705     -816.3602      -816.3602     
Loop time of 57.9123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.087 hours/ns, 17.268 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.759     | 57.759     | 57.759     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021683   | 0.021683   | 0.021683   |   0.0 |  0.04
Output  | 4.2651e-05 | 4.2651e-05 | 4.2651e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.21
Other   |            | 0.01051    |            |       |  0.02

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

Total # of neighbors = 313716
Ave neighs/atom = 78.429
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.692533695487, Press = -1.39030761398488
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17521.574     -17521.574     -17660.712     -17660.712      269.17125      269.17125      44110.705      44110.705     -816.3602      -816.3602     
     23000  -17515.883     -17515.883     -17657.684     -17657.684      274.32354      274.32354      44091.584      44091.584      339.45343      339.45343    
Loop time of 57.8508 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.070 hours/ns, 17.286 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.698     | 57.698     | 57.698     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021608   | 0.021608   | 0.021608   |   0.0 |  0.04
Output  | 5.7198e-05 | 5.7198e-05 | 5.7198e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313710
Ave neighs/atom = 78.4275
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.671133548631, Press = -0.556200806219902
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17515.883     -17515.883     -17657.684     -17657.684      274.32354      274.32354      44091.584      44091.584      339.45343      339.45343    
     24000  -17516.485     -17516.485     -17658.089     -17658.089      273.9433       273.9433       44105.192      44105.192     -292.85173     -292.85173    
Loop time of 57.8456 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.494 ns/day, 16.068 hours/ns, 17.287 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.692     | 57.692     | 57.692     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021693   | 0.021693   | 0.021693   |   0.0 |  0.04
Output  | 5.4443e-05 | 5.4443e-05 | 5.4443e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.21
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 313826
Ave neighs/atom = 78.4565
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.659409945804, Press = -0.149488948507818
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17516.485     -17516.485     -17658.089     -17658.089      273.9433       273.9433       44105.192      44105.192     -292.85173     -292.85173    
     25000  -17515.604     -17515.604     -17656.068     -17656.068      271.73842      271.73842      44111.795      44111.795     -377.40794     -377.40794    
Loop time of 57.9377 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.094 hours/ns, 17.260 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.784     | 57.784     | 57.784     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02168    | 0.02168    | 0.02168    |   0.0 |  0.04
Output  | 5.7188e-05 | 5.7188e-05 | 5.7188e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.21
Other   |            | 0.01042    |            |       |  0.02

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

Total # of neighbors = 313816
Ave neighs/atom = 78.454
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.735557721583, Press = -0.865519311387974
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17515.604     -17515.604     -17656.068     -17656.068      271.73842      271.73842      44111.795      44111.795     -377.40794     -377.40794    
     26000  -17518.555     -17518.555     -17656.217     -17656.217      266.31719      266.31719      44076.029      44076.029      1063.5037      1063.5037    
Loop time of 57.8684 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.493 ns/day, 16.075 hours/ns, 17.281 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.715     | 57.715     | 57.715     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021606   | 0.021606   | 0.021606   |   0.0 |  0.04
Output  | 3.8953e-05 | 3.8953e-05 | 3.8953e-05 |   0.0 |  0.00
Modify  | 0.12116    | 0.12116    | 0.12116    |   0.0 |  0.21
Other   |            | 0.01043    |            |       |  0.02

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

Total # of neighbors = 313800
Ave neighs/atom = 78.45
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.821083677785, Press = -1.41342136938494
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17518.555     -17518.555     -17656.217     -17656.217      266.31719      266.31719      44076.029      44076.029      1063.5037      1063.5037    
     27000  -17519.585     -17519.585     -17660.255     -17660.255      272.13638      272.13638      44101.146      44101.146     -397.44523     -397.44523    
Loop time of 57.9123 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.087 hours/ns, 17.267 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.759     | 57.759     | 57.759     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021653   | 0.021653   | 0.021653   |   0.0 |  0.04
Output  | 3.6339e-05 | 3.6339e-05 | 3.6339e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.21
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 313906
Ave neighs/atom = 78.4765
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.848791993753, Press = 0.984861313889731
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17519.585     -17519.585     -17660.255     -17660.255      272.13638      272.13638      44101.146      44101.146     -397.44523     -397.44523    
     28000  -17515.27      -17515.27      -17656.266     -17656.266      272.76674      272.76674      44135.557      44135.557     -1380.6738     -1380.6738    
Loop time of 57.9535 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.098 hours/ns, 17.255 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.8       | 57.8       | 57.8       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021681   | 0.021681   | 0.021681   |   0.0 |  0.04
Output  | 3.689e-05  | 3.689e-05  | 3.689e-05  |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.21
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 313882
Ave neighs/atom = 78.4705
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.811536229368, Press = -2.45048214458166
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17515.27      -17515.27      -17656.266     -17656.266      272.76674      272.76674      44135.557      44135.557     -1380.6738     -1380.6738    
     29000  -17521.11      -17521.11      -17658.617     -17658.617      266.01732      266.01732      44039.518      44039.518      2339.1686      2339.1686    
Loop time of 58.0454 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.124 hours/ns, 17.228 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.892     | 57.892     | 57.892     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021628   | 0.021628   | 0.021628   |   0.0 |  0.04
Output  | 3.8192e-05 | 3.8192e-05 | 3.8192e-05 |   0.0 |  0.00
Modify  | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313814
Ave neighs/atom = 78.4535
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.767676818098, Press = -0.838200459973568
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17521.11      -17521.11      -17658.617     -17658.617      266.01732      266.01732      44039.518      44039.518      2339.1686      2339.1686    
     30000  -17517.489     -17517.489     -17657.557     -17657.557      270.97171      270.97171      44107.511      44107.511     -391.53374     -391.53374    
Loop time of 57.9248 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.492 ns/day, 16.090 hours/ns, 17.264 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.772     | 57.772     | 57.772     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021616   | 0.021616   | 0.021616   |   0.0 |  0.04
Output  | 3.738e-05  | 3.738e-05  | 3.738e-05  |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  0.21
Other   |            | 0.01042    |            |       |  0.02

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

Total # of neighbors = 313886
Ave neighs/atom = 78.4715
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.772481274443, Press = 0.619045523894029
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17517.489     -17517.489     -17657.557     -17657.557      270.97171      270.97171      44107.511      44107.511     -391.53374     -391.53374    
     31000  -17511.068     -17511.068     -17654.126     -17654.126      276.75569      276.75569      44110.839      44110.839     -79.024587     -79.024587    
Loop time of 58.0038 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.112 hours/ns, 17.240 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.851     | 57.851     | 57.851     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021663   | 0.021663   | 0.021663   |   0.0 |  0.04
Output  | 3.6599e-05 | 3.6599e-05 | 3.6599e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313788
Ave neighs/atom = 78.447
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.816483364212, Press = -1.13705440838049
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17511.068     -17511.068     -17654.126     -17654.126      276.75569      276.75569      44110.839      44110.839     -79.024587     -79.024587    
     32000  -17516.739     -17516.739     -17657.827     -17657.827      272.94541      272.94541      44088.271      44088.271      362.14527      362.14527    
Loop time of 58.1365 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.149 hours/ns, 17.201 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.983     | 57.983     | 57.983     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021642   | 0.021642   | 0.021642   |   0.0 |  0.04
Output  | 3.7831e-05 | 3.7831e-05 | 3.7831e-05 |   0.0 |  0.00
Modify  | 0.12109    | 0.12109    | 0.12109    |   0.0 |  0.21
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 313938
Ave neighs/atom = 78.4845
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.856081793027, Press = -0.309272637894999
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17516.739     -17516.739     -17657.827     -17657.827      272.94541      272.94541      44088.271      44088.271      362.14527      362.14527    
     33000  -17511.809     -17511.809     -17654.959     -17654.959      276.93409      276.93409      44130.775      44130.775     -1024.3935     -1024.3935    
Loop time of 58.0532 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.126 hours/ns, 17.226 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.9       | 57.9       | 57.9       |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021736   | 0.021736   | 0.021736   |   0.0 |  0.04
Output  | 4.4314e-05 | 4.4314e-05 | 4.4314e-05 |   0.0 |  0.00
Modify  | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.21
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 313818
Ave neighs/atom = 78.4545
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.938645704217, Press = -0.453404291040394
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17511.809     -17511.809     -17654.959     -17654.959      276.93409      276.93409      44130.775      44130.775     -1024.3935     -1024.3935    
     34000  -17514.042     -17514.042     -17655.363     -17655.363      273.39687      273.39687      44090.769      44090.769      632.25609      632.25609    
Loop time of 57.9518 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.098 hours/ns, 17.256 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.799     | 57.799     | 57.799     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021587   | 0.021587   | 0.021587   |   0.0 |  0.04
Output  | 4.1077e-05 | 4.1077e-05 | 4.1077e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.21
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 313810
Ave neighs/atom = 78.4525
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.92725544899, Press = -2.58204860119186
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17514.042     -17514.042     -17655.363     -17655.363      273.39687      273.39687      44090.769      44090.769      632.25609      632.25609    
     35000  -17518.755     -17518.755     -17657.89      -17657.89       269.1652       269.1652       44058.052      44058.052      1631.0227      1631.0227    
Loop time of 58.1794 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.161 hours/ns, 17.188 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.026     | 58.026     | 58.026     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021681   | 0.021681   | 0.021681   |   0.0 |  0.04
Output  | 4.231e-05  | 4.231e-05  | 4.231e-05  |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  0.21
Other   |            | 0.01043    |            |       |  0.02

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

Total # of neighbors = 313890
Ave neighs/atom = 78.4725
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.964686242805, Press = 1.29499774062638
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17518.755     -17518.755     -17657.89      -17657.89       269.1652       269.1652       44058.052      44058.052      1631.0227      1631.0227    
     36000  -17513.491     -17513.491     -17655.893     -17655.893      275.48672      275.48672      44142.738      44142.738     -1545.9414     -1545.9414    
Loop time of 57.9981 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.111 hours/ns, 17.242 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.845     | 57.845     | 57.845     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021804   | 0.021804   | 0.021804   |   0.0 |  0.04
Output  | 4.2721e-05 | 4.2721e-05 | 4.2721e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.21
Other   |            | 0.0104     |            |       |  0.02

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

Total # of neighbors = 313954
Ave neighs/atom = 78.4885
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.012567634854, Press = -0.436648202123234
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17513.491     -17513.491     -17655.893     -17655.893      275.48672      275.48672      44142.738      44142.738     -1545.9414     -1545.9414    
     37000  -17518.652     -17518.652     -17658.403     -17658.403      270.35723      270.35723      44085.35       44085.35       520.09237      520.09237    
Loop time of 57.9553 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.491 ns/day, 16.099 hours/ns, 17.255 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.802     | 57.802     | 57.802     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021689   | 0.021689   | 0.021689   |   0.0 |  0.04
Output  | 3.8462e-05 | 3.8462e-05 | 3.8462e-05 |   0.0 |  0.00
Modify  | 0.12104    | 0.12104    | 0.12104    |   0.0 |  0.21
Other   |            | 0.01045    |            |       |  0.02

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

Total # of neighbors = 313840
Ave neighs/atom = 78.46
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.039843550475, Press = -1.21314996694856
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17518.652     -17518.652     -17658.403     -17658.403      270.35723      270.35723      44085.35       44085.35       520.09237      520.09237    
     38000  -17512.748     -17512.748     -17655.881     -17655.881      276.90018      276.90018      44098.356      44098.356      250.42677      250.42677    
Loop time of 58.0813 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.134 hours/ns, 17.217 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.928     | 57.928     | 57.928     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021635   | 0.021635   | 0.021635   |   0.0 |  0.04
Output  | 2.8924e-05 | 2.8924e-05 | 2.8924e-05 |   0.0 |  0.00
Modify  | 0.12103    | 0.12103    | 0.12103    |   0.0 |  0.21
Other   |            | 0.01042    |            |       |  0.02

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

Total # of neighbors = 313842
Ave neighs/atom = 78.4605
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.047344210617, Press = 0.263861970799605
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17512.748     -17512.748     -17655.881     -17655.881      276.90018      276.90018      44098.356      44098.356      250.42677      250.42677    
     39000  -17515.805     -17515.805     -17656.523     -17656.523      272.22847      272.22847      44116.279      44116.279     -542.58121     -542.58121    
Loop time of 58.1163 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.143 hours/ns, 17.207 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.963     | 57.963     | 57.963     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021607   | 0.021607   | 0.021607   |   0.0 |  0.04
Output  | 4.5005e-05 | 4.5005e-05 | 4.5005e-05 |   0.0 |  0.00
Modify  | 0.12098    | 0.12098    | 0.12098    |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313916
Ave neighs/atom = 78.479
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.048090829183, Press = -0.659025224832249
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17515.805     -17515.805     -17656.523     -17656.523      272.22847      272.22847      44116.279      44116.279     -542.58121     -542.58121    
     40000  -17517.135     -17517.135     -17657.762     -17657.762      272.05312      272.05312      44073.531      44073.531      1027.2913      1027.2913    
Loop time of 58.096 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.487 ns/day, 16.138 hours/ns, 17.213 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.943     | 57.943     | 57.943     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021782   | 0.021782   | 0.021782   |   0.0 |  0.04
Output  | 4.6979e-05 | 4.6979e-05 | 4.6979e-05 |   0.0 |  0.00
Modify  | 0.12093    | 0.12093    | 0.12093    |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313726
Ave neighs/atom = 78.4315
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.04811235153, Press = -0.996524460179803
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17517.135     -17517.135     -17657.762     -17657.762      272.05312      272.05312      44073.531      44073.531      1027.2913      1027.2913    
     41000  -17517.584     -17517.584     -17656.551     -17656.551      268.84076      268.84076      44081.55       44081.55       825.14223      825.14223    
Loop time of 58.0807 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.488 ns/day, 16.134 hours/ns, 17.217 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.927     | 57.927     | 57.927     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021642   | 0.021642   | 0.021642   |   0.0 |  0.04
Output  | 4.6257e-05 | 4.6257e-05 | 4.6257e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.21
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453
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.073227395938, Press = 1.53849523742321
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17517.584     -17517.584     -17656.551     -17656.551      268.84076      268.84076      44081.55       44081.55       825.14223      825.14223    
     42000  -17514.178     -17514.178     -17654.096     -17654.096      270.68096      270.68096      44150.648      44150.648     -1862.6419     -1862.6419    
Loop time of 57.9869 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.490 ns/day, 16.107 hours/ns, 17.245 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    | 57.833     | 57.833     | 57.833     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021667   | 0.021667   | 0.021667   |   0.0 |  0.04
Output  | 4.4744e-05 | 4.4744e-05 | 4.4744e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.21
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 313874
Ave neighs/atom = 78.4685
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.043059668379, Press = -1.05132632545274
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17514.178     -17514.178     -17654.096     -17654.096      270.68096      270.68096      44150.648      44150.648     -1862.6419     -1862.6419    
     43000  -17519.861     -17519.861     -17657.314     -17657.314      265.91265      265.91265      44073.217      44073.217      996.48379      996.48379    
Loop time of 58.1327 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.148 hours/ns, 17.202 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    | 57.979     | 57.979     | 57.979     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021656   | 0.021656   | 0.021656   |   0.0 |  0.04
Output  | 4.5857e-05 | 4.5857e-05 | 4.5857e-05 |   0.0 |  0.00
Modify  | 0.12113    | 0.12113    | 0.12113    |   0.0 |  0.21
Other   |            | 0.01051    |            |       |  0.02

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

Total # of neighbors = 313794
Ave neighs/atom = 78.4485
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.015043073676, Press = -0.758121573025897
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17519.861     -17519.861     -17657.314     -17657.314      265.91265      265.91265      44073.217      44073.217      996.48379      996.48379    
     44000  -17513.147     -17513.147     -17654.737     -17654.737      273.91539      273.91539      44105.792      44105.792      19.697846      19.697846    
Loop time of 58.1698 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.485 ns/day, 16.158 hours/ns, 17.191 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    | 58.017     | 58.017     | 58.017     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021695   | 0.021695   | 0.021695   |   0.0 |  0.04
Output  | 4.5305e-05 | 4.5305e-05 | 4.5305e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.21
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 313912
Ave neighs/atom = 78.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"
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
44100.9392148132

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0