# 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.5213917642831802*${_u_distance}
variable latticeconst_converted equal 3.5213917642831802*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139176428318
Lattice spacing in x,y,z = 3.5213918 3.5213918 3.5213918
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213918 35.213918 35.213918)
  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.213918 35.213918 35.213918)
  create_atoms CPU = 0.006 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_AsadiZaeemNouranian_2015_Ni__MO_700541006254_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.9620060214    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9620060214/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9620060214/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9620060214/(1*1*${_u_distance})
variable      V0_metal equal 43665.9620060214/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9620060214*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9620060214 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_700541006254_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17669.144     -17669.144     -17800         -17800          253.15         253.15         43665.962      43665.962      3200.8815      3200.8815    
      1000  -17530.499     -17530.499     -17660.845     -17660.845      252.16364      252.16364      44058.223      44058.223     -1339.2419     -1339.2419    
Loop time of 316.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.273 ns/day, 87.857 hours/ns, 3.162 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    | 315.39     | 315.39     | 315.39     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13965    | 0.13965    | 0.13965    |   0.0 |  0.04
Output  | 0.00024292 | 0.00024292 | 0.00024292 |   0.0 |  0.00
Modify  | 0.65371    | 0.65371    | 0.65371    |   0.0 |  0.21
Other   |            | 0.09718    |            |       |  0.03

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

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

Performance: 0.253 ns/day, 94.914 hours/ns, 2.927 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    | 340.76     | 340.76     | 340.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14675    | 0.14675    | 0.14675    |   0.0 |  0.04
Output  | 0.00022624 | 0.00022624 | 0.00022624 |   0.0 |  0.00
Modify  | 0.68104    | 0.68104    | 0.68104    |   0.0 |  0.20
Other   |            | 0.09829    |            |       |  0.03

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

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

Performance: 0.260 ns/day, 92.247 hours/ns, 3.011 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    | 331.2      | 331.2      | 331.2      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13864    | 0.13864    | 0.13864    |   0.0 |  0.04
Output  | 0.00028441 | 0.00028441 | 0.00028441 |   0.0 |  0.00
Modify  | 0.65106    | 0.65106    | 0.65106    |   0.0 |  0.20
Other   |            | 0.09664    |            |       |  0.03

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:       314020 ave      314020 max      314020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.263 ns/day, 91.320 hours/ns, 3.042 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    | 327.87     | 327.87     | 327.87     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13967    | 0.13967    | 0.13967    |   0.0 |  0.04
Output  | 0.00023166 | 0.00023166 | 0.00023166 |   0.0 |  0.00
Modify  | 0.64384    | 0.64384    | 0.64384    |   0.0 |  0.20
Other   |            | 0.09594    |            |       |  0.03

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:       313898 ave      313898 max      313898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.250 ns/day, 96.022 hours/ns, 2.893 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    | 344.74     | 344.74     | 344.74     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.04
Output  | 0.00029177 | 0.00029177 | 0.00029177 |   0.0 |  0.00
Modify  | 0.69208    | 0.69208    | 0.69208    |   0.0 |  0.20
Other   |            | 0.0996     |            |       |  0.03

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:       314042 ave      314042 max      314042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314042
Ave neighs/atom = 78.5105
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 = 251.097662893274, Press = -498.346784542127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17539.193     -17539.193     -17669.664     -17669.664      252.40662      252.40662      43989.487      43989.487      975.55725      975.55725    
      6000  -17534.406     -17534.406     -17665.749     -17665.749      254.09127      254.09127      44070.664      44070.664     -2187.5146     -2187.5146    
Loop time of 360.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.011 hours/ns, 2.777 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    | 359.03     | 359.03     | 359.03     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15502    | 0.15502    | 0.15502    |   0.0 |  0.04
Output  | 0.00023316 | 0.00023316 | 0.00023316 |   0.0 |  0.00
Modify  | 0.75913    | 0.75913    | 0.75913    |   0.0 |  0.21
Other   |            | 0.09968    |            |       |  0.03

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

Total # of neighbors = 313874
Ave neighs/atom = 78.4685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.846858820045, Press = -29.1989617746148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17534.406     -17534.406     -17665.749     -17665.749      254.09127      254.09127      44070.664      44070.664     -2187.5146     -2187.5146    
      7000  -17538.388     -17538.388     -17666.39      -17666.39       247.6275       247.6275       43961.244      43961.244      2248.283       2248.283     
Loop time of 340.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.688 hours/ns, 2.934 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    | 339.93     | 339.93     | 339.93     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14675    | 0.14675    | 0.14675    |   0.0 |  0.04
Output  | 0.00023631 | 0.00023631 | 0.00023631 |   0.0 |  0.00
Modify  | 0.70092    | 0.70092    | 0.70092    |   0.0 |  0.21
Other   |            | 0.096      |            |       |  0.03

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:       313852 ave      313852 max      313852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313852
Ave neighs/atom = 78.463
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 = 252.990971643854, Press = 8.25624546397198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17538.388     -17538.388     -17666.39      -17666.39       247.6275       247.6275       43961.244      43961.244      2248.283       2248.283     
      8000  -17536.632     -17536.632     -17666.325     -17666.325      250.90011      250.90011      44022.148      44022.148     -208.45777     -208.45777    
Loop time of 329.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.629 hours/ns, 3.032 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    | 328.96     | 328.96     | 328.96     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14187    | 0.14187    | 0.14187    |   0.0 |  0.04
Output  | 0.00019532 | 0.00019532 | 0.00019532 |   0.0 |  0.00
Modify  | 0.67208    | 0.67208    | 0.67208    |   0.0 |  0.20
Other   |            | 0.09351    |            |       |  0.03

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:       313996 ave      313996 max      313996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313996
Ave neighs/atom = 78.499
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 = 252.881800534096, Press = -18.5768294810073
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17536.632     -17536.632     -17666.325     -17666.325      250.90011      250.90011      44022.148      44022.148     -208.45777     -208.45777    
      9000  -17540.336     -17540.336     -17672.459     -17672.459      255.60206      255.60206      44017.373      44017.373     -530.17106     -530.17106    
Loop time of 329.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.629 hours/ns, 3.032 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    | 328.95     | 328.95     | 328.95     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14261    | 0.14261    | 0.14261    |   0.0 |  0.04
Output  | 0.00019407 | 0.00019407 | 0.00019407 |   0.0 |  0.00
Modify  | 0.67192    | 0.67192    | 0.67192    |   0.0 |  0.20
Other   |            | 0.09311    |            |       |  0.03

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:       313880 ave      313880 max      313880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313880
Ave neighs/atom = 78.47
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 = 252.491458986187, Press = -4.40863378229289
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17540.336     -17540.336     -17672.459     -17672.459      255.60206      255.60206      44017.373      44017.373     -530.17106     -530.17106    
     10000  -17536.131     -17536.131     -17665.818     -17665.818      250.88837      250.88837      44006.832      44006.832      440.41955      440.41955    
Loop time of 330.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.692 hours/ns, 3.029 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    | 329.18     | 329.18     | 329.18     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14352    | 0.14352    | 0.14352    |   0.0 |  0.04
Output  | 0.00023744 | 0.00023744 | 0.00023744 |   0.0 |  0.00
Modify  | 0.67262    | 0.67262    | 0.67262    |   0.0 |  0.20
Other   |            | 0.09317    |            |       |  0.03

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

Total # of neighbors = 313726
Ave neighs/atom = 78.4315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.550661093664, Press = -6.86478094278272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17536.131     -17536.131     -17665.818     -17665.818      250.88837      250.88837      44006.832      44006.832      440.41955      440.41955    
     11000  -17539.834     -17539.834     -17670.694     -17670.694      253.15928      253.15928      44018.373      44018.373     -376.83231     -376.83231    
Loop time of 330.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.728 hours/ns, 3.028 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    | 329.31     | 329.31     | 329.31     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14341    | 0.14341    | 0.14341    |   0.0 |  0.04
Output  | 0.00019455 | 0.00019455 | 0.00019455 |   0.0 |  0.00
Modify  | 0.67135    | 0.67135    | 0.67135    |   0.0 |  0.20
Other   |            | 0.09326    |            |       |  0.03

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:       313920 ave      313920 max      313920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313920
Ave neighs/atom = 78.48
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 = 252.374932339599, Press = -6.13350192592857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17539.834     -17539.834     -17670.694     -17670.694      253.15928      253.15928      44018.373      44018.373     -376.83231     -376.83231    
     12000  -17538.453     -17538.453     -17664.608     -17664.608      244.05569      244.05569      44009.752      44009.752      392.28499      392.28499    
Loop time of 337.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.753 hours/ns, 2.963 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    | 336.58     | 336.58     | 336.58     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14356    | 0.14356    | 0.14356    |   0.0 |  0.04
Output  | 0.00019441 | 0.00019441 | 0.00019441 |   0.0 |  0.00
Modify  | 0.68978    | 0.68978    | 0.68978    |   0.0 |  0.20
Other   |            | 0.09564    |            |       |  0.03

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:       313824 ave      313824 max      313824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313824
Ave neighs/atom = 78.456
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 = 252.412959599516, Press = -1.89479265553043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17538.453     -17538.453     -17664.608     -17664.608      244.05569      244.05569      44009.752      44009.752      392.28499      392.28499    
     13000  -17535.523     -17535.523     -17665.375     -17665.375      251.20762      251.20762      43988.753      43988.753      1350.5635      1350.5635    
Loop time of 330.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.888 hours/ns, 3.023 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    | 329.89     | 329.89     | 329.89     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14093    | 0.14093    | 0.14093    |   0.0 |  0.04
Output  | 0.00019141 | 0.00019141 | 0.00019141 |   0.0 |  0.00
Modify  | 0.67431    | 0.67431    | 0.67431    |   0.0 |  0.20
Other   |            | 0.09574    |            |       |  0.03

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:       313904 ave      313904 max      313904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313904
Ave neighs/atom = 78.476
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 = 252.457433593891, Press = -6.81329907717426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17535.523     -17535.523     -17665.375     -17665.375      251.20762      251.20762      43988.753      43988.753      1350.5635      1350.5635    
     14000  -17536.898     -17536.898     -17667.668     -17667.668      252.98175      252.98175      44061.341      44061.341     -1938.5119     -1938.5119    
Loop time of 328.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.161 hours/ns, 3.047 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    | 327.28     | 327.28     | 327.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13831    | 0.13831    | 0.13831    |   0.0 |  0.04
Output  | 0.0005016  | 0.0005016  | 0.0005016  |   0.0 |  0.00
Modify  | 0.66739    | 0.66739    | 0.66739    |   0.0 |  0.20
Other   |            | 0.09601    |            |       |  0.03

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:       313972 ave      313972 max      313972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313972
Ave neighs/atom = 78.493
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 = 252.726353640222, Press = -3.38179403934388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17536.898     -17536.898     -17667.668     -17667.668      252.98175      252.98175      44061.341      44061.341     -1938.5119     -1938.5119    
     15000  -17537.062     -17537.062     -17668.433     -17668.433      254.14503      254.14503      43972.741      43972.741      1744.8885      1744.8885    
Loop time of 327.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 90.993 hours/ns, 3.053 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    | 326.67     | 326.67     | 326.67     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13899    | 0.13899    | 0.13899    |   0.0 |  0.04
Output  | 0.00023735 | 0.00023735 | 0.00023735 |   0.0 |  0.00
Modify  | 0.66674    | 0.66674    | 0.66674    |   0.0 |  0.20
Other   |            | 0.09596    |            |       |  0.03

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:       313834 ave      313834 max      313834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313834
Ave neighs/atom = 78.4585
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 = 252.85847130488, Press = 0.432440534523179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17537.062     -17537.062     -17668.433     -17668.433      254.14503      254.14503      43972.741      43972.741      1744.8885      1744.8885    
     16000  -17540.365     -17540.365     -17670.572     -17670.572      251.894        251.894        44023.033      44023.033     -605.56051     -605.56051    
Loop time of 328.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.305 hours/ns, 3.042 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    | 327.8      | 327.8      | 327.8      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13959    | 0.13959    | 0.13959    |   0.0 |  0.04
Output  | 0.0002348  | 0.0002348  | 0.0002348  |   0.0 |  0.00
Modify  | 0.6665     | 0.6665     | 0.6665     |   0.0 |  0.20
Other   |            | 0.09612    |            |       |  0.03

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:       313922 ave      313922 max      313922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313922
Ave neighs/atom = 78.4805
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 = 252.959532978936, Press = -5.85367723479301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17540.365     -17540.365     -17670.572     -17670.572      251.894        251.894        44023.033      44023.033     -605.56051     -605.56051    
     17000  -17535.91      -17535.91      -17667.108     -17667.108      253.81126      253.81126      44025.379      44025.379     -308.65886     -308.65886    
Loop time of 328.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.263 ns/day, 91.149 hours/ns, 3.048 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    | 327.23     | 327.23     | 327.23     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13839    | 0.13839    | 0.13839    |   0.0 |  0.04
Output  | 0.0001923  | 0.0001923  | 0.0001923  |   0.0 |  0.00
Modify  | 0.66754    | 0.66754    | 0.66754    |   0.0 |  0.20
Other   |            | 0.09608    |            |       |  0.03

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:       313782 ave      313782 max      313782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313782
Ave neighs/atom = 78.4455
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 = 252.948232998695, Press = 0.137084565895328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17535.91      -17535.91      -17667.108     -17667.108      253.81126      253.81126      44025.379      44025.379     -308.65886     -308.65886    
     18000  -17536.396     -17536.396     -17667.074     -17667.074      252.80406      252.80406      43990.575      43990.575      1096.4781      1096.4781    
Loop time of 327.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 90.989 hours/ns, 3.053 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    | 326.66     | 326.66     | 326.66     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1393     | 0.1393     | 0.1393     |   0.0 |  0.04
Output  | 0.00023362 | 0.00023362 | 0.00023362 |   0.0 |  0.00
Modify  | 0.6667     | 0.6667     | 0.6667     |   0.0 |  0.20
Other   |            | 0.09579    |            |       |  0.03

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

Total # of neighbors = 313816
Ave neighs/atom = 78.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.985931439265, Press = -4.5824527532938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17536.396     -17536.396     -17667.074     -17667.074      252.80406      252.80406      43990.575      43990.575      1096.4781      1096.4781    
     19000  -17536.086     -17536.086     -17667.923     -17667.923      255.04798      255.04798      44058.83       44058.83      -1794.2248     -1794.2248    
Loop time of 327.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 91.076 hours/ns, 3.050 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    | 326.97     | 326.97     | 326.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13923    | 0.13923    | 0.13923    |   0.0 |  0.04
Output  | 0.00019209 | 0.00019209 | 0.00019209 |   0.0 |  0.00
Modify  | 0.66606    | 0.66606    | 0.66606    |   0.0 |  0.20
Other   |            | 0.09514    |            |       |  0.03

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:       313862 ave      313862 max      313862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313862
Ave neighs/atom = 78.4655
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 = 253.048979789493, Press = -2.12142225691221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17536.086     -17536.086     -17667.923     -17667.923      255.04798      255.04798      44058.83       44058.83      -1794.2248     -1794.2248    
     20000  -17539.694     -17539.694     -17667.009     -17667.009      246.29967      246.29967      43976.748      43976.748      1565.706       1565.706     
Loop time of 327.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 91.023 hours/ns, 3.052 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    | 326.78     | 326.78     | 326.78     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13896    | 0.13896    | 0.13896    |   0.0 |  0.04
Output  | 0.00019173 | 0.00019173 | 0.00019173 |   0.0 |  0.00
Modify  | 0.66585    | 0.66585    | 0.66585    |   0.0 |  0.20
Other   |            | 0.09537    |            |       |  0.03

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:       313822 ave      313822 max      313822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313822
Ave neighs/atom = 78.4555
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 = 253.114833476752, Press = -0.558205510825224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17539.694     -17539.694     -17667.009     -17667.009      246.29967      246.29967      43976.748      43976.748      1565.706       1565.706     
     21000  -17539.346     -17539.346     -17669.481     -17669.481      251.75431      251.75431      44029.599      44029.599     -770.327       -770.327      
Loop time of 327.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 90.981 hours/ns, 3.053 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    | 326.63     | 326.63     | 326.63     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1392     | 0.1392     | 0.1392     |   0.0 |  0.04
Output  | 0.00023536 | 0.00023536 | 0.00023536 |   0.0 |  0.00
Modify  | 0.66582    | 0.66582    | 0.66582    |   0.0 |  0.20
Other   |            | 0.094      |            |       |  0.03

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:       313976 ave      313976 max      313976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313976
Ave neighs/atom = 78.494
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 = 253.0939056389, Press = -5.20976481226674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17539.346     -17539.346     -17669.481     -17669.481      251.75431      251.75431      44029.599      44029.599     -770.327       -770.327      
     22000  -17536.286     -17536.286     -17669.744     -17669.744      258.18512      258.18512      44032.873      44032.873     -906.37823     -906.37823    
Loop time of 327.273 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 90.909 hours/ns, 3.056 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    | 326.37     | 326.37     | 326.37     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13908    | 0.13908    | 0.13908    |   0.0 |  0.04
Output  | 0.00019075 | 0.00019075 | 0.00019075 |   0.0 |  0.00
Modify  | 0.66645    | 0.66645    | 0.66645    |   0.0 |  0.20
Other   |            | 0.09455    |            |       |  0.03

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:       313798 ave      313798 max      313798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313798
Ave neighs/atom = 78.4495
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 = 252.997341075068, Press = 1.80713956744812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17536.286     -17536.286     -17669.744     -17669.744      258.18512      258.18512      44032.873      44032.873     -906.37823     -906.37823    
     23000  -17538.907     -17538.907     -17669.325     -17669.325      252.30284      252.30284      43966.403      43966.403      1842.9736      1842.9736    
Loop time of 327.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 91.029 hours/ns, 3.052 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    | 326.81     | 326.81     | 326.81     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13771    | 0.13771    | 0.13771    |   0.0 |  0.04
Output  | 0.00019211 | 0.00019211 | 0.00019211 |   0.0 |  0.00
Modify  | 0.66615    | 0.66615    | 0.66615    |   0.0 |  0.20
Other   |            | 0.09466    |            |       |  0.03

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:       313856 ave      313856 max      313856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313856
Ave neighs/atom = 78.464
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 = 252.978153431078, Press = -2.90158805776569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17538.907     -17538.907     -17669.325     -17669.325      252.30284      252.30284      43966.403      43966.403      1842.9736      1842.9736    
     24000  -17535.405     -17535.405     -17667.923     -17667.923      256.36597      256.36597      44038.614      44038.614     -1055.5324     -1055.5324    
Loop time of 327.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.264 ns/day, 91.076 hours/ns, 3.050 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    | 326.97     | 326.97     | 326.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13885    | 0.13885    | 0.13885    |   0.0 |  0.04
Output  | 0.00019152 | 0.00019152 | 0.00019152 |   0.0 |  0.00
Modify  | 0.66561    | 0.66561    | 0.66561    |   0.0 |  0.20
Other   |            | 0.09541    |            |       |  0.03

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:       313920 ave      313920 max      313920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313920
Ave neighs/atom = 78.48
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 = 253.026647538296, Press = -1.72248041899207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17535.405     -17535.405     -17667.923     -17667.923      256.36597      256.36597      44038.614      44038.614     -1055.5324     -1055.5324    
     25000  -17541.21      -17541.21      -17669.797     -17669.797      248.76002      248.76002      43997.634      43997.634      471.38223      471.38223    
Loop time of 335.938 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.316 hours/ns, 2.977 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    | 335.01     | 335.01     | 335.01     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14399    | 0.14399    | 0.14399    |   0.0 |  0.04
Output  | 0.00019536 | 0.00019536 | 0.00019536 |   0.0 |  0.00
Modify  | 0.69069    | 0.69069    | 0.69069    |   0.0 |  0.21
Other   |            | 0.09545    |            |       |  0.03

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

Total # of neighbors = 313796
Ave neighs/atom = 78.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.002104375007, Press = -0.515097838275721
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17541.21      -17541.21      -17669.797     -17669.797      248.76002      248.76002      43997.634      43997.634      471.38223      471.38223    
     26000  -17538.36      -17538.36      -17666.879     -17666.879      248.62736      248.62736      44007.754      44007.754      376.70757      376.70757    
Loop time of 330.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.667 hours/ns, 3.030 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    | 329.09     | 329.09     | 329.09     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14398    | 0.14398    | 0.14398    |   0.0 |  0.04
Output  | 0.00019594 | 0.00019594 | 0.00019594 |   0.0 |  0.00
Modify  | 0.66984    | 0.66984    | 0.66984    |   0.0 |  0.20
Other   |            | 0.09328    |            |       |  0.03

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

Total # of neighbors = 313826
Ave neighs/atom = 78.4565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.002446257881, Press = -2.43442262251778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17538.36      -17538.36      -17666.879     -17666.879      248.62736      248.62736      44007.754      44007.754      376.70757      376.70757    
     27000  -17533.128     -17533.128     -17667.779     -17667.779      260.49156      260.49156      44079.326      44079.326     -2710.7301     -2710.7301    
Loop time of 329.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.540 hours/ns, 3.034 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    | 328.64     | 328.64     | 328.64     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14345    | 0.14345    | 0.14345    |   0.0 |  0.04
Output  | 0.00019049 | 0.00019049 | 0.00019049 |   0.0 |  0.00
Modify  | 0.66977    | 0.66977    | 0.66977    |   0.0 |  0.20
Other   |            | 0.09299    |            |       |  0.03

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:       313838 ave      313838 max      313838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313838
Ave neighs/atom = 78.4595
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 = 253.054681802283, Press = 0.301440270556271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17533.128     -17533.128     -17667.779     -17667.779      260.49156      260.49156      44079.326      44079.326     -2710.7301     -2710.7301    
     28000  -17537.713     -17537.713     -17667.266     -17667.266      250.62909      250.62909      43939.122      43939.122      3234.0689      3234.0689    
Loop time of 329.497 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.527 hours/ns, 3.035 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    | 328.59     | 328.59     | 328.59     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14315    | 0.14315    | 0.14315    |   0.0 |  0.04
Output  | 0.00019076 | 0.00019076 | 0.00019076 |   0.0 |  0.00
Modify  | 0.67035    | 0.67035    | 0.67035    |   0.0 |  0.20
Other   |            | 0.09315    |            |       |  0.03

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:       313792 ave      313792 max      313792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313792
Ave neighs/atom = 78.448
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 = 253.144601956611, Press = -1.21678036922472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17537.713     -17537.713     -17667.266     -17667.266      250.62909      250.62909      43939.122      43939.122      3234.0689      3234.0689    
     29000  -17534.492     -17534.492     -17666.581     -17666.581      255.53519      255.53519      44056.118      44056.118     -1612.9668     -1612.9668    
Loop time of 336.78 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.550 hours/ns, 2.969 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    | 335.85     | 335.85     | 335.85     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14411    | 0.14411    | 0.14411    |   0.0 |  0.04
Output  | 0.00019125 | 0.00019125 | 0.00019125 |   0.0 |  0.00
Modify  | 0.69277    | 0.69277    | 0.69277    |   0.0 |  0.21
Other   |            | 0.09634    |            |       |  0.03

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:       314016 ave      314016 max      314016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314016
Ave neighs/atom = 78.504
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 = 253.141516872379, Press = -2.6249187712213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17534.492     -17534.492     -17666.581     -17666.581      255.53519      255.53519      44056.118      44056.118     -1612.9668     -1612.9668    
     30000  -17538.275     -17538.275     -17669.055     -17669.055      253.00236      253.00236      44008.065      44008.065      142.90479      142.90479    
Loop time of 370.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.989 hours/ns, 2.697 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    | 369.72     | 369.72     | 369.72     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15546    | 0.15546    | 0.15546    |   0.0 |  0.04
Output  | 0.00026216 | 0.00026216 | 0.00026216 |   0.0 |  0.00
Modify  | 0.78685    | 0.78685    | 0.78685    |   0.0 |  0.21
Other   |            | 0.1032     |            |       |  0.03

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:       313862 ave      313862 max      313862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313862
Ave neighs/atom = 78.4655
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
44014.6254321398

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0