# 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.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
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.005 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_KoGrabowskiNeugebauer_2015_NiTi__MO_663355627503_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.9611745232    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9611745232*1000

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 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.7683      3453.7683    
      1000  -17508.879     -17508.879     -17649.246     -17649.246      271.55122      271.55122      44136.4        44136.4       -1137.0155     -1137.0155    
Loop time of 430.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.588 hours/ns, 2.323 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.5      | 429.5      | 429.5      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1573     | 0.1573     | 0.1573     |   0.0 |  0.04
Output  | 0.00034685 | 0.00034685 | 0.00034685 |   0.0 |  0.00
Modify  | 0.75262    | 0.75262    | 0.75262    |   0.0 |  0.17
Other   |            | 0.1025     |            |       |  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:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17508.879     -17508.879     -17649.246     -17649.246      271.55122      271.55122      44136.4        44136.4       -1137.0155     -1137.0155    
      2000  -17516.944     -17516.944     -17659.373     -17659.373      275.53686      275.53686      44096.34       44096.34      -382.76575     -382.76575    
Loop time of 410.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.160 hours/ns, 2.433 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 409.98     | 409.98     | 409.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15991    | 0.15991    | 0.15991    |   0.0 |  0.04
Output  | 0.00022864 | 0.00022864 | 0.00022864 |   0.0 |  0.00
Modify  | 0.73582    | 0.73582    | 0.73582    |   0.0 |  0.18
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6128 ave        6128 max        6128 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:       540954 ave      540954 max      540954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.211 ns/day, 113.478 hours/ns, 2.448 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 407.53     | 407.53     | 407.53     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16061    | 0.16061    | 0.16061    |   0.0 |  0.04
Output  | 0.00028938 | 0.00028938 | 0.00028938 |   0.0 |  0.00
Modify  | 0.73012    | 0.73012    | 0.73012    |   0.0 |  0.18
Other   |            | 0.09968    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 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:       540890 ave      540890 max      540890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.217 ns/day, 110.361 hours/ns, 2.517 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 396.34     | 396.34     | 396.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15659    | 0.15659    | 0.15659    |   0.0 |  0.04
Output  | 0.00023154 | 0.00023154 | 0.00023154 |   0.0 |  0.00
Modify  | 0.70613    | 0.70613    | 0.70613    |   0.0 |  0.18
Other   |            | 0.09777    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 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:       541096 ave      541096 max      541096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.201 ns/day, 119.266 hours/ns, 2.329 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.29     | 428.29     | 428.29     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16796    | 0.16796    | 0.16796    |   0.0 |  0.04
Output  | 0.00018819 | 0.00018819 | 0.00018819 |   0.0 |  0.00
Modify  | 0.79454    | 0.79454    | 0.79454    |   0.0 |  0.19
Other   |            | 0.1057     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 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:       540978 ave      540978 max      540978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540978
Ave neighs/atom = 135.2445
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.531691750519, Press = -380.749484467654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17518.809     -17518.809     -17660.899     -17660.899      274.88132      274.88132      44088.433      44088.433     -267.16671     -267.16671    
      6000  -17513.33      -17513.33      -17655.541     -17655.541      275.11658      275.11658      44054.637      44054.637      1660.6306      1660.6306    
Loop time of 429.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.396 hours/ns, 2.327 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.74     | 428.74     | 428.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16979    | 0.16979    | 0.16979    |   0.0 |  0.04
Output  | 0.00019141 | 0.00019141 | 0.00019141 |   0.0 |  0.00
Modify  | 0.81022    | 0.81022    | 0.81022    |   0.0 |  0.19
Other   |            | 0.1034     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6138 ave        6138 max        6138 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:       541012 ave      541012 max      541012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541012
Ave neighs/atom = 135.253
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.780834036184, Press = 6.00906596742689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17513.33      -17513.33      -17655.541     -17655.541      275.11658      275.11658      44054.637      44054.637      1660.6306      1660.6306    
      7000  -17519.045     -17519.045     -17661.592     -17661.592      275.76701      275.76701      44131.034      44131.034     -2019.6401     -2019.6401    
Loop time of 395.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.903 hours/ns, 2.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394.67     | 394.67     | 394.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15747    | 0.15747    | 0.15747    |   0.0 |  0.04
Output  | 0.00018984 | 0.00018984 | 0.00018984 |   0.0 |  0.00
Modify  | 0.72638    | 0.72638    | 0.72638    |   0.0 |  0.18
Other   |            | 0.09851    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6196 ave        6196 max        6196 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:       541168 ave      541168 max      541168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541168
Ave neighs/atom = 135.292
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.050120195366, Press = 11.1554972097184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17519.045     -17519.045     -17661.592     -17661.592      275.76701      275.76701      44131.034      44131.034     -2019.6401     -2019.6401    
      8000  -17515.287     -17515.287     -17658.406     -17658.406      276.8726       276.8726       44116.322      44116.322     -1125.7174     -1125.7174    
Loop time of 430.114 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.476 hours/ns, 2.325 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.03     | 429.03     | 429.03     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16539    | 0.16539    | 0.16539    |   0.0 |  0.04
Output  | 0.00019112 | 0.00019112 | 0.00019112 |   0.0 |  0.00
Modify  | 0.8186     | 0.8186     | 0.8186     |   0.0 |  0.19
Other   |            | 0.1049     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6082 ave        6082 max        6082 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:       540820 ave      540820 max      540820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540820
Ave neighs/atom = 135.205
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.944066528152, Press = -24.5879654363025
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17515.287     -17515.287     -17658.406     -17658.406      276.8726       276.8726       44116.322      44116.322     -1125.7174     -1125.7174    
      9000  -17520.423     -17520.423     -17658.187     -17658.187      266.51326      266.51326      44048.808      44048.808      1610.2561      1610.2561    
Loop time of 438.333 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.759 hours/ns, 2.281 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 437.21     | 437.21     | 437.21     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17095    | 0.17095    | 0.17095    |   0.0 |  0.04
Output  | 0.00019086 | 0.00019086 | 0.00019086 |   0.0 |  0.00
Modify  | 0.84305    | 0.84305    | 0.84305    |   0.0 |  0.19
Other   |            | 0.1075     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6141 ave        6141 max        6141 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:       540774 ave      540774 max      540774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540774
Ave neighs/atom = 135.1935
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.589204529223, Press = -2.6705810046159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17520.423     -17520.423     -17658.187     -17658.187      266.51326      266.51326      44048.808      44048.808      1610.2561      1610.2561    
     10000  -17514.543     -17514.543     -17655.998     -17655.998      273.65482      273.65482      44103.1        44103.1       -307.29819     -307.29819    
Loop time of 439.956 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.210 hours/ns, 2.273 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 438.82     | 438.82     | 438.82     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1715     | 0.1715     | 0.1715     |   0.0 |  0.04
Output  | 0.00019269 | 0.00019269 | 0.00019269 |   0.0 |  0.00
Modify  | 0.85411    | 0.85411    | 0.85411    |   0.0 |  0.19
Other   |            | 0.1069     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6077 ave        6077 max        6077 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:       541154 ave      541154 max      541154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541154
Ave neighs/atom = 135.2885
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.584455184004, Press = 0.719659125220152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17514.543     -17514.543     -17655.998     -17655.998      273.65482      273.65482      44103.1        44103.1       -307.29819     -307.29819    
     11000  -17518.762     -17518.762     -17660.667     -17660.667      274.52536      274.52536      44105.959      44105.959     -931.33242     -931.33242    
Loop time of 412.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.543 hours/ns, 2.425 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 411.32     | 411.32     | 411.32     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16317    | 0.16317    | 0.16317    |   0.0 |  0.04
Output  | 0.00018901 | 0.00018901 | 0.00018901 |   0.0 |  0.00
Modify  | 0.77052    | 0.77052    | 0.77052    |   0.0 |  0.19
Other   |            | 0.1029     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6192 ave        6192 max        6192 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:       540954 ave      540954 max      540954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540954
Ave neighs/atom = 135.2385
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.471702759823, Press = -4.25745944225804
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17518.762     -17518.762     -17660.667     -17660.667      274.52536      274.52536      44105.959      44105.959     -931.33242     -931.33242    
     12000  -17516.919     -17516.919     -17657.484     -17657.484      271.93198      271.93198      44062.876      44062.876      1230.6524      1230.6524    
Loop time of 416.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.815 hours/ns, 2.398 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 415.89     | 415.89     | 415.89     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16301    | 0.16301    | 0.16301    |   0.0 |  0.04
Output  | 0.00026778 | 0.00026778 | 0.00026778 |   0.0 |  0.00
Modify  | 0.78367    | 0.78367    | 0.78367    |   0.0 |  0.19
Other   |            | 0.1032     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6095 ave        6095 max        6095 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:       540986 ave      540986 max      540986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540986
Ave neighs/atom = 135.2465
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.699129111913, Press = -2.24728119851607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17516.919     -17516.919     -17657.484     -17657.484      271.93198      271.93198      44062.876      44062.876      1230.6524      1230.6524    
     13000  -17516.37      -17516.37      -17654.887     -17654.887      267.97047      267.97047      44090.955      44090.955      286.03763      286.03763    
Loop time of 433.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.473 hours/ns, 2.306 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 432.6      | 432.6      | 432.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16945    | 0.16945    | 0.16945    |   0.0 |  0.04
Output  | 0.00019848 | 0.00019848 | 0.00019848 |   0.0 |  0.00
Modify  | 0.82618    | 0.82618    | 0.82618    |   0.0 |  0.19
Other   |            | 0.1048     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6156 ave        6156 max        6156 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:       541134 ave      541134 max      541134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541134
Ave neighs/atom = 135.2835
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.866281256523, Press = 3.45897867016207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17516.37      -17516.37      -17654.887     -17654.887      267.97047      267.97047      44090.955      44090.955      286.03763      286.03763    
     14000  -17521.597     -17521.597     -17660.261     -17660.261      268.25535      268.25535      44112.123      44112.123     -1241.1393     -1241.1393    
Loop time of 382.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.151 hours/ns, 2.617 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.21     | 381.21     | 381.21     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15488    | 0.15488    | 0.15488    |   0.0 |  0.04
Output  | 0.00019068 | 0.00019068 | 0.00019068 |   0.0 |  0.00
Modify  | 0.68885    | 0.68885    | 0.68885    |   0.0 |  0.18
Other   |            | 0.09281    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6116 ave        6116 max        6116 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:       541008 ave      541008 max      541008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541008
Ave neighs/atom = 135.252
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.891204553542, Press = -4.0386580720783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17521.597     -17521.597     -17660.261     -17660.261      268.25535      268.25535      44112.123      44112.123     -1241.1393     -1241.1393    
     15000  -17515.413     -17515.413     -17657.485     -17657.485      274.84807      274.84807      44054.984      44054.984      1481.8077      1481.8077    
Loop time of 406.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.828 hours/ns, 2.462 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 405.16     | 405.16     | 405.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1613     | 0.1613     | 0.1613     |   0.0 |  0.04
Output  | 0.00019323 | 0.00019323 | 0.00019323 |   0.0 |  0.00
Modify  | 0.756      | 0.756      | 0.756      |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6158 ave        6158 max        6158 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:       540958 ave      540958 max      540958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540958
Ave neighs/atom = 135.2395
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.82157494142, Press = -2.96857524213785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17515.413     -17515.413     -17657.485     -17657.485      274.84807      274.84807      44054.984      44054.984      1481.8077      1481.8077    
     16000  -17518.966     -17518.966     -17658.693     -17658.693      270.31097      270.31097      44095.436      44095.436     -388.31605     -388.31605    
Loop time of 421.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.067 hours/ns, 2.373 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.38     | 420.38     | 420.38     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16802    | 0.16802    | 0.16802    |   0.0 |  0.04
Output  | 0.0001915  | 0.0001915  | 0.0001915  |   0.0 |  0.00
Modify  | 0.79487    | 0.79487    | 0.79487    |   0.0 |  0.19
Other   |            | 0.1026     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6150 ave        6150 max        6150 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:       541130 ave      541130 max      541130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541130
Ave neighs/atom = 135.2825
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.698262169179, Press = 3.2592803070938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17518.966     -17518.966     -17658.693     -17658.693      270.31097      270.31097      44095.436      44095.436     -388.31605     -388.31605    
     17000  -17517.193     -17517.193     -17654.257     -17654.257      265.15999      265.15999      44150.905      44150.905     -2328.4143     -2328.4143    
Loop time of 409.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.790 hours/ns, 2.441 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 408.6      | 408.6      | 408.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1636     | 0.1636     | 0.1636     |   0.0 |  0.04
Output  | 0.00030448 | 0.00030448 | 0.00030448 |   0.0 |  0.00
Modify  | 0.77305    | 0.77305    | 0.77305    |   0.0 |  0.19
Other   |            | 0.103      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6145 ave        6145 max        6145 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:       540996 ave      540996 max      540996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540996
Ave neighs/atom = 135.249
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.695398595467, Press = -5.06657838554574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17517.193     -17517.193     -17654.257     -17654.257      265.15999      265.15999      44150.905      44150.905     -2328.4143     -2328.4143    
     18000  -17517.116     -17517.116     -17658.522     -17658.522      273.55976      273.55976      44024.567      44024.567      2663.1281      2663.1281    
Loop time of 428.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.970 hours/ns, 2.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 427.22     | 427.22     | 427.22     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16729    | 0.16729    | 0.16729    |   0.0 |  0.04
Output  | 0.00026493 | 0.00026493 | 0.00026493 |   0.0 |  0.00
Modify  | 0.80205    | 0.80205    | 0.80205    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 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:       540870 ave      540870 max      540870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540870
Ave neighs/atom = 135.2175
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.564321563318, Press = -3.03552324755964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17517.116     -17517.116     -17658.522     -17658.522      273.55976      273.55976      44024.567      44024.567      2663.1281      2663.1281    
     19000  -17518.016     -17518.016     -17661.742     -17661.742      278.04885      278.04885      44086.425      44086.425     -224.9573      -224.9573     
Loop time of 441.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.587 hours/ns, 2.266 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    | 440.19     | 440.19     | 440.19     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17035    | 0.17035    | 0.17035    |   0.0 |  0.04
Output  | 0.000193   | 0.000193   | 0.000193   |   0.0 |  0.00
Modify  | 0.8413     | 0.8413     | 0.8413     |   0.0 |  0.19
Other   |            | 0.1082     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 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:       541332 ave      541332 max      541332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541332
Ave neighs/atom = 135.333
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.634776797226, Press = 1.68805172945811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17518.016     -17518.016     -17661.742     -17661.742      278.04885      278.04885      44086.425      44086.425     -224.9573      -224.9573     
     20000  -17514.638     -17514.638     -17659.818     -17659.818      280.86072      280.86072      44118.106      44118.106     -1287.0232     -1287.0232    
Loop time of 432.757 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.210 hours/ns, 2.311 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    | 431.66     | 431.66     | 431.66     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16794    | 0.16794    | 0.16794    |   0.0 |  0.04
Output  | 0.00019623 | 0.00019623 | 0.00019623 |   0.0 |  0.00
Modify  | 0.82182    | 0.82182    | 0.82182    |   0.0 |  0.19
Other   |            | 0.1049     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6139 ave        6139 max        6139 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:       541004 ave      541004 max      541004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541004
Ave neighs/atom = 135.251
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.620311913459, Press = -1.03493342944581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17514.638     -17514.638     -17659.818     -17659.818      280.86072      280.86072      44118.106      44118.106     -1287.0232     -1287.0232    
     21000  -17517.959     -17517.959     -17657.079     -17657.079      269.13639      269.13639      44066.66       44066.66       1025.6203      1025.6203    
Loop time of 426.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.585 hours/ns, 2.342 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.81     | 425.81     | 425.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16666    | 0.16666    | 0.16666    |   0.0 |  0.04
Output  | 0.00018901 | 0.00018901 | 0.00018901 |   0.0 |  0.00
Modify  | 0.81975    | 0.81975    | 0.81975    |   0.0 |  0.19
Other   |            | 0.1055     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6085 ave        6085 max        6085 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:       540910 ave      540910 max      540910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540910
Ave neighs/atom = 135.2275
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.550969123722, Press = -1.46452620331427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17517.959     -17517.959     -17657.079     -17657.079      269.13639      269.13639      44066.66       44066.66       1025.6203      1025.6203    
     22000  -17517.125     -17517.125     -17658.153     -17658.153      272.82786      272.82786      44070.754      44070.754      793.46586      793.46586    
Loop time of 425.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.170 hours/ns, 2.351 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 424.32     | 424.32     | 424.32     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17211    | 0.17211    | 0.17211    |   0.0 |  0.04
Output  | 0.00019374 | 0.00019374 | 0.00019374 |   0.0 |  0.00
Modify  | 0.82101    | 0.82101    | 0.82101    |   0.0 |  0.19
Other   |            | 0.1034     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6144 ave        6144 max        6144 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:       541080 ave      541080 max      541080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541080
Ave neighs/atom = 135.27
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.622664772657, Press = 2.7416237568015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17517.125     -17517.125     -17658.153     -17658.153      272.82786      272.82786      44070.754      44070.754      793.46586      793.46586    
     23000  -17513.845     -17513.845     -17655.458     -17655.458      273.96114      273.96114      44176.583      44176.583     -3264.2445     -3264.2445    
Loop time of 438.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.898 hours/ns, 2.279 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 437.73     | 437.73     | 437.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16848    | 0.16848    | 0.16848    |   0.0 |  0.04
Output  | 0.00019451 | 0.00019451 | 0.00019451 |   0.0 |  0.00
Modify  | 0.83383    | 0.83383    | 0.83383    |   0.0 |  0.19
Other   |            | 0.1057     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 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:       541056 ave      541056 max      541056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541056
Ave neighs/atom = 135.264
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.620908949994, Press = -1.20930237325859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17513.845     -17513.845     -17655.458     -17655.458      273.96114      273.96114      44176.583      44176.583     -3264.2445     -3264.2445    
     24000  -17521.542     -17521.542     -17659.395     -17659.395      266.68662      266.68662      44055.149      44055.149      1234.1342      1234.1342    
Loop time of 441.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.619 hours/ns, 2.265 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 440.3      | 440.3      | 440.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17262    | 0.17262    | 0.17262    |   0.0 |  0.04
Output  | 0.00019616 | 0.00019616 | 0.00019616 |   0.0 |  0.00
Modify  | 0.84883    | 0.84883    | 0.84883    |   0.0 |  0.19
Other   |            | 0.108      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 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:       540598 ave      540598 max      540598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540598
Ave neighs/atom = 135.1495
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.560714672095, Press = -2.42398214855658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17521.542     -17521.542     -17659.395     -17659.395      266.68662      266.68662      44055.149      44055.149      1234.1342      1234.1342    
     25000  -17513.709     -17513.709     -17656.959     -17656.959      277.12734      277.12734      44079.239      44079.239      634.60152      634.60152    
Loop time of 422.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.434 hours/ns, 2.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.7      | 421.7      | 421.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16473    | 0.16473    | 0.16473    |   0.0 |  0.04
Output  | 0.00029837 | 0.00029837 | 0.00029837 |   0.0 |  0.00
Modify  | 0.79737    | 0.79737    | 0.79737    |   0.0 |  0.19
Other   |            | 0.1035     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6076 ave        6076 max        6076 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:       541146 ave      541146 max      541146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541146
Ave neighs/atom = 135.2865
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.583775266439, Press = 1.55377676216062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17513.709     -17513.709     -17656.959     -17656.959      277.12734      277.12734      44079.239      44079.239      634.60152      634.60152    
     26000  -17519.891     -17519.891     -17659.553     -17659.553      270.18467      270.18467      44116.522      44116.522     -1289.5684     -1289.5684    
Loop time of 419.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.659 hours/ns, 2.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 418.92     | 418.92     | 418.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16522    | 0.16522    | 0.16522    |   0.0 |  0.04
Output  | 0.00019415 | 0.00019415 | 0.00019415 |   0.0 |  0.00
Modify  | 0.78544    | 0.78544    | 0.78544    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6157 ave        6157 max        6157 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:       541084 ave      541084 max      541084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541084
Ave neighs/atom = 135.271
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.585166462531, Press = -0.526633480196847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17519.891     -17519.891     -17659.553     -17659.553      270.18467      270.18467      44116.522      44116.522     -1289.5684     -1289.5684    
     27000  -17513.82      -17513.82      -17655.084     -17655.084      273.28557      273.28557      44089.572      44089.572      306.43344      306.43344    
Loop time of 384.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.827 hours/ns, 2.600 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.61     | 383.61     | 383.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16875    | 0.16875    | 0.16875    |   0.0 |  0.04
Output  | 0.00021067 | 0.00021067 | 0.00021067 |   0.0 |  0.00
Modify  | 0.70456    | 0.70456    | 0.70456    |   0.0 |  0.18
Other   |            | 0.09161    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 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:       540828 ave      540828 max      540828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540828
Ave neighs/atom = 135.207
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.585830040008, Press = -1.67530114765689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17513.82      -17513.82      -17655.084     -17655.084      273.28557      273.28557      44089.572      44089.572      306.43344      306.43344    
     28000  -17517.175     -17517.175     -17659.995     -17659.995      276.29548      276.29548      44071.66       44071.66       604.78936      604.78936    
Loop time of 423.937 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.760 hours/ns, 2.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 422.88     | 422.88     | 422.88     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16842    | 0.16842    | 0.16842    |   0.0 |  0.04
Output  | 0.00019435 | 0.00019435 | 0.00019435 |   0.0 |  0.00
Modify  | 0.78949    | 0.78949    | 0.78949    |   0.0 |  0.19
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 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:       541058 ave      541058 max      541058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541058
Ave neighs/atom = 135.2645
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.686103440069, Press = 1.27018298757928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17517.175     -17517.175     -17659.995     -17659.995      276.29548      276.29548      44071.66       44071.66       604.78936      604.78936    
     29000  -17511.933     -17511.933     -17655.355     -17655.355      277.4594       277.4594       44172.496      44172.496     -3054.8884     -3054.8884    
Loop time of 428.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.959 hours/ns, 2.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 427.17     | 427.17     | 427.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16666    | 0.16666    | 0.16666    |   0.0 |  0.04
Output  | 0.00019128 | 0.00019128 | 0.00019128 |   0.0 |  0.00
Modify  | 0.81015    | 0.81015    | 0.81015    |   0.0 |  0.19
Other   |            | 0.1044     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 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:       541036 ave      541036 max      541036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541036
Ave neighs/atom = 135.259
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.747900140629, Press = -0.651758919711325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17511.933     -17511.933     -17655.355     -17655.355      277.4594       277.4594       44172.496      44172.496     -3054.8884     -3054.8884    
     30000  -17516.333     -17516.333     -17657.758     -17657.758      273.59553      273.59553      44070.195      44070.195      797.02389      797.02389    
Loop time of 412.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.480 hours/ns, 2.426 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 411.09     | 411.09     | 411.09     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16248    | 0.16248    | 0.16248    |   0.0 |  0.04
Output  | 0.00019303 | 0.00019303 | 0.00019303 |   0.0 |  0.00
Modify  | 0.77114    | 0.77114    | 0.77114    |   0.0 |  0.19
Other   |            | 0.1016     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6126 ave        6126 max        6126 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:       540616 ave      540616 max      540616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540616
Ave neighs/atom = 135.154
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.720671764069, Press = -1.75586088385066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17516.333     -17516.333     -17657.758     -17657.758      273.59553      273.59553      44070.195      44070.195      797.02389      797.02389    
     31000  -17519.283     -17519.283     -17660.072     -17660.072      272.3651       272.3651       44070.453      44070.453      593.30648      593.30648    
Loop time of 437.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.415 hours/ns, 2.288 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 435.96     | 435.96     | 435.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17569    | 0.17569    | 0.17569    |   0.0 |  0.04
Output  | 0.00020288 | 0.00020288 | 0.00020288 |   0.0 |  0.00
Modify  | 0.85428    | 0.85428    | 0.85428    |   0.0 |  0.20
Other   |            | 0.1067     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6114 ave        6114 max        6114 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:       540984 ave      540984 max      540984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540984
Ave neighs/atom = 135.246
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.709507423827, Press = 0.426737035205325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17519.283     -17519.283     -17660.072     -17660.072      272.3651       272.3651       44070.453      44070.453      593.30648      593.30648    
     32000  -17512.634     -17512.634     -17657.894     -17657.894      281.01402      281.01402      44117.674      44117.674     -1069.38       -1069.38      
Loop time of 422.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.241 hours/ns, 2.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421        | 421        | 421        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16728    | 0.16728    | 0.16728    |   0.0 |  0.04
Output  | 0.00023452 | 0.00023452 | 0.00023452 |   0.0 |  0.00
Modify  | 0.7978     | 0.7978     | 0.7978     |   0.0 |  0.19
Other   |            | 0.1029     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 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:       541000 ave      541000 max      541000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541000
Ave neighs/atom = 135.25
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.725455303185, Press = -0.162415098019515
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17512.634     -17512.634     -17657.894     -17657.894      281.01402      281.01402      44117.674      44117.674     -1069.38       -1069.38      
     33000  -17517.028     -17517.028     -17658.357     -17658.357      273.41125      273.41125      44084.312      44084.312      205.69864      205.69864    
Loop time of 418.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.148 hours/ns, 2.392 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 417.08     | 417.08     | 417.08     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16416    | 0.16416    | 0.16416    |   0.0 |  0.04
Output  | 0.00024424 | 0.00024424 | 0.00024424 |   0.0 |  0.00
Modify  | 0.78447    | 0.78447    | 0.78447    |   0.0 |  0.19
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6125 ave        6125 max        6125 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:       540962 ave      540962 max      540962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540962
Ave neighs/atom = 135.2405
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.792486813838, Press = -1.5609111980422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17517.028     -17517.028     -17658.357     -17658.357      273.41125      273.41125      44084.312      44084.312      205.69864      205.69864    
     34000  -17514.531     -17514.531     -17656.246     -17656.246      274.15581      274.15581      44012.399      44012.399      3364.9431      3364.9431    
Loop time of 404.835 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.454 hours/ns, 2.470 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 403.83     | 403.83     | 403.83     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16067    | 0.16067    | 0.16067    |   0.0 |  0.04
Output  | 0.00026703 | 0.00026703 | 0.00026703 |   0.0 |  0.00
Modify  | 0.74517    | 0.74517    | 0.74517    |   0.0 |  0.18
Other   |            | 0.1011     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6125 ave        6125 max        6125 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:       541018 ave      541018 max      541018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541018
Ave neighs/atom = 135.2545
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.815592545837, Press = 1.57232156663453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17514.531     -17514.531     -17656.246     -17656.246      274.15581      274.15581      44012.399      44012.399      3364.9431      3364.9431    
     35000  -17516.882     -17516.882     -17655.647     -17655.647      268.45009      268.45009      44134.85       44134.85      -1626.864      -1626.864     
Loop time of 408.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.406 hours/ns, 2.449 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 407.23     | 407.23     | 407.23     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1648     | 0.1648     | 0.1648     |   0.0 |  0.04
Output  | 0.00026268 | 0.00026268 | 0.00026268 |   0.0 |  0.00
Modify  | 0.76891    | 0.76891    | 0.76891    |   0.0 |  0.19
Other   |            | 0.1009     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6200 ave        6200 max        6200 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:       541390 ave      541390 max      541390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541390
Ave neighs/atom = 135.3475
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.873396569523, Press = 0.796479432773635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17516.882     -17516.882     -17655.647     -17655.647      268.45009      268.45009      44134.85       44134.85      -1626.864      -1626.864     
     36000  -17514.338     -17514.338     -17658.056     -17658.056      278.03391      278.03391      44100.989      44100.989     -392.4916      -392.4916     
Loop time of 418.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.125 hours/ns, 2.392 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 416.96     | 416.96     | 416.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17308    | 0.17308    | 0.17308    |   0.0 |  0.04
Output  | 0.00019493 | 0.00019493 | 0.00019493 |   0.0 |  0.00
Modify  | 0.80954    | 0.80954    | 0.80954    |   0.0 |  0.19
Other   |            | 0.1028     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6127 ave        6127 max        6127 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:       540846 ave      540846 max      540846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540846
Ave neighs/atom = 135.2115
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.877404504433, Press = -1.20983464345943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17514.338     -17514.338     -17658.056     -17658.056      278.03391      278.03391      44100.989      44100.989     -392.4916      -392.4916     
     37000  -17519.261     -17519.261     -17657.346     -17657.346      267.13493      267.13493      44058.641      44058.641      1232.8719      1232.8719    
Loop time of 435.02 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.839 hours/ns, 2.299 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 433.9      | 433.9      | 433.9      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17614    | 0.17614    | 0.17614    |   0.0 |  0.04
Output  | 0.00021525 | 0.00021525 | 0.00021525 |   0.0 |  0.00
Modify  | 0.83556    | 0.83556    | 0.83556    |   0.0 |  0.19
Other   |            | 0.1051     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6136 ave        6136 max        6136 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:       540840 ave      540840 max      540840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540840
Ave neighs/atom = 135.21
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.904368968486, Press = 0.507754980528402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17519.261     -17519.261     -17657.346     -17657.346      267.13493      267.13493      44058.641      44058.641      1232.8719      1232.8719    
     38000  -17515.456     -17515.456     -17656.047     -17656.047      271.98271      271.98271      44133.342      44133.342     -1602.3124     -1602.3124    
Loop time of 422.417 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.338 hours/ns, 2.367 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.33     | 421.33     | 421.33     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17004    | 0.17004    | 0.17004    |   0.0 |  0.04
Output  | 0.0002761  | 0.0002761  | 0.0002761  |   0.0 |  0.00
Modify  | 0.80939    | 0.80939    | 0.80939    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6156 ave        6156 max        6156 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:       541226 ave      541226 max      541226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541226
Ave neighs/atom = 135.3065
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.876698460152, Press = 0.435451389283588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17515.456     -17515.456     -17656.047     -17656.047      271.98271      271.98271      44133.342      44133.342     -1602.3124     -1602.3124    
     39000  -17520.023     -17520.023     -17659.877     -17659.877      270.55546      270.55546      44094.658      44094.658     -400.23825     -400.23825    
Loop time of 435.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.058 hours/ns, 2.295 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 434.69     | 434.69     | 434.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17242    | 0.17242    | 0.17242    |   0.0 |  0.04
Output  | 0.00019369 | 0.00019369 | 0.00019369 |   0.0 |  0.00
Modify  | 0.83568    | 0.83568    | 0.83568    |   0.0 |  0.19
Other   |            | 0.1063     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6197 ave        6197 max        6197 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:       540882 ave      540882 max      540882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540882
Ave neighs/atom = 135.2205
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.863410795782, Press = -2.67712912553705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17520.023     -17520.023     -17659.877     -17659.877      270.55546      270.55546      44094.658      44094.658     -400.23825     -400.23825    
     40000  -17513.148     -17513.148     -17656.143     -17656.143      276.63252      276.63252      44040.636      44040.636      2302.8515      2302.8515    
Loop time of 433.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.318 hours/ns, 2.309 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 432.05     | 432.05     | 432.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16982    | 0.16982    | 0.16982    |   0.0 |  0.04
Output  | 0.0001956  | 0.0001956  | 0.0001956  |   0.0 |  0.00
Modify  | 0.82229    | 0.82229    | 0.82229    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6071 ave        6071 max        6071 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:       541034 ave      541034 max      541034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541034
Ave neighs/atom = 135.2585
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.849910927988, Press = 0.963518525391761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17513.148     -17513.148     -17656.143     -17656.143      276.63252      276.63252      44040.636      44040.636      2302.8515      2302.8515    
     41000  -17519.136     -17519.136     -17659.814     -17659.814      272.1508       272.1508       44115.388      44115.388     -1245.9997     -1245.9997    
Loop time of 424.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.007 hours/ns, 2.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 423.75     | 423.75     | 423.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16965    | 0.16965    | 0.16965    |   0.0 |  0.04
Output  | 0.00026876 | 0.00026876 | 0.00026876 |   0.0 |  0.00
Modify  | 0.80236    | 0.80236    | 0.80236    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6189 ave        6189 max        6189 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:       541276 ave      541276 max      541276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541276
Ave neighs/atom = 135.319
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.873994307748, Press = 0.206643317568504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17519.136     -17519.136     -17659.814     -17659.814      272.1508       272.1508       44115.388      44115.388     -1245.9997     -1245.9997    
     42000  -17513.77      -17513.77      -17655.523     -17655.523      274.22919      274.22919      44099.483      44099.483     -219.75371     -219.75371    
Loop time of 437.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.397 hours/ns, 2.288 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 435.92     | 435.92     | 435.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17038    | 0.17038    | 0.17038    |   0.0 |  0.04
Output  | 0.00023609 | 0.00023609 | 0.00023609 |   0.0 |  0.00
Modify  | 0.83439    | 0.83439    | 0.83439    |   0.0 |  0.19
Other   |            | 0.1049     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6114 ave        6114 max        6114 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:       540904 ave      540904 max      540904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540904
Ave neighs/atom = 135.226
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.912607357819, Press = -1.08011922567997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17513.77      -17513.77      -17655.523     -17655.523      274.22919      274.22919      44099.483      44099.483     -219.75371     -219.75371    
     43000  -17518.551     -17518.551     -17659.055     -17659.055      271.81388      271.81388      44053.045      44053.045      1377.2568      1377.2568    
Loop time of 429.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.413 hours/ns, 2.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.78     | 428.78     | 428.78     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17103    | 0.17103    | 0.17103    |   0.0 |  0.04
Output  | 0.00026239 | 0.00026239 | 0.00026239 |   0.0 |  0.00
Modify  | 0.82895    | 0.82895    | 0.82895    |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6190 ave        6190 max        6190 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:       541136 ave      541136 max      541136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541136
Ave neighs/atom = 135.284
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.946956339895, Press = 0.32627568941384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17518.551     -17518.551     -17659.055     -17659.055      271.81388      271.81388      44053.045      44053.045      1377.2568      1377.2568    
     44000  -17511.331     -17511.331     -17656.528     -17656.528      280.89313      280.89313      44140.38       44140.38      -1915.2318     -1915.2318    
Loop time of 416.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.802 hours/ns, 2.399 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 415.82     | 415.82     | 415.82     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17417    | 0.17417    | 0.17417    |   0.0 |  0.04
Output  | 0.00018933 | 0.00018933 | 0.00018933 |   0.0 |  0.00
Modify  | 0.79565    | 0.79565    | 0.79565    |   0.0 |  0.19
Other   |            | 0.1017     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6155 ave        6155 max        6155 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:       541256 ave      541256 max      541256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541256
Ave neighs/atom = 135.314
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.986311512529, Press = 1.12139965662192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17511.331     -17511.331     -17656.528     -17656.528      280.89313      280.89313      44140.38       44140.38      -1915.2318     -1915.2318    
     45000  -17517.96      -17517.96      -17655.621     -17655.621      266.31401      266.31401      44128.211      44128.211     -1422.6968     -1422.6968    
Loop time of 432.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.216 hours/ns, 2.311 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 431.66     | 431.66     | 431.66     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17974    | 0.17974    | 0.17974    |   0.0 |  0.04
Output  | 0.00053691 | 0.00053691 | 0.00053691 |   0.0 |  0.00
Modify  | 0.82985    | 0.82985    | 0.82985    |   0.0 |  0.19
Other   |            | 0.1037     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6142 ave        6142 max        6142 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:       540862 ave      540862 max      540862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540862
Ave neighs/atom = 135.2155
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.010607356171, Press = -1.8939411099148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17517.96      -17517.96      -17655.621     -17655.621      266.31401      266.31401      44128.211      44128.211     -1422.6968     -1422.6968    
     46000  -17520.632     -17520.632     -17660.276     -17660.276      270.15063      270.15063      44043.175      44043.175      1625.5616      1625.5616    
Loop time of 408.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.542 hours/ns, 2.446 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 407.72     | 407.72     | 407.72     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16103    | 0.16103    | 0.16103    |   0.0 |  0.04
Output  | 0.00020306 | 0.00020306 | 0.00020306 |   0.0 |  0.00
Modify  | 0.77186    | 0.77186    | 0.77186    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 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:       540970 ave      540970 max      540970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540970
Ave neighs/atom = 135.2425
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
44091.0495244427

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0