# 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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  -17648.467     -17648.467     -17800         -17800          293.15         293.15         43665.962      43665.962      3706.6504      3706.6504    
      1000  -17487.386     -17487.386     -17638.319     -17638.319      291.9894       291.9894       44037.59       44037.59       1944.9234      1944.9234    
Loop time of 318.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.271 ns/day, 88.487 hours/ns, 3.139 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    | 317.66     | 317.66     | 317.66     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14105    | 0.14105    | 0.14105    |   0.0 |  0.04
Output  | 0.00023724 | 0.00023724 | 0.00023724 |   0.0 |  0.00
Modify  | 0.65465    | 0.65465    | 0.65465    |   0.0 |  0.21
Other   |            | 0.0988     |            |       |  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  -17487.386     -17487.386     -17638.319     -17638.319      291.9894       291.9894       44037.59       44037.59       1944.9234      1944.9234    
      2000  -17495.7       -17495.7       -17652.34      -17652.34       303.03045      303.03045      44068.78       44068.78      -324.49876     -324.49876    
Loop time of 343.101 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.306 hours/ns, 2.915 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    | 342.17     | 342.17     | 342.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14753    | 0.14753    | 0.14753    |   0.0 |  0.04
Output  | 0.00022973 | 0.00022973 | 0.00022973 |   0.0 |  0.00
Modify  | 0.68304    | 0.68304    | 0.68304    |   0.0 |  0.20
Other   |            | 0.09847    |            |       |  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:       314474 ave      314474 max      314474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314474
Ave neighs/atom = 78.6185
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  -17495.7       -17495.7       -17652.34      -17652.34       303.03045      303.03045      44068.78       44068.78      -324.49876     -324.49876    
      3000  -17495.743     -17495.743     -17648.265     -17648.265      295.06475      295.06475      44075.158      44075.158     -289.66248     -289.66248    
Loop time of 342.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.082 hours/ns, 2.921 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    | 341.37     | 341.37     | 341.37     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14753    | 0.14753    | 0.14753    |   0.0 |  0.04
Output  | 0.00023811 | 0.00023811 | 0.00023811 |   0.0 |  0.00
Modify  | 0.67837    | 0.67837    | 0.67837    |   0.0 |  0.20
Other   |            | 0.09569    |            |       |  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:       314288 ave      314288 max      314288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314288
Ave neighs/atom = 78.572
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  -17495.743     -17495.743     -17648.265     -17648.265      295.06475      295.06475      44075.158      44075.158     -289.66248     -289.66248    
      4000  -17493.17      -17493.17      -17641.492     -17641.492      286.9379       286.9379       44081.984      44081.984     -131.9589      -131.9589     
Loop time of 331.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.016 hours/ns, 3.019 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    | 330.37     | 330.37     | 330.37     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14535    | 0.14535    | 0.14535    |   0.0 |  0.04
Output  | 0.00023461 | 0.00023461 | 0.00023461 |   0.0 |  0.00
Modify  | 0.64525    | 0.64525    | 0.64525    |   0.0 |  0.19
Other   |            | 0.09282    |            |       |  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:       314098 ave      314098 max      314098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314098
Ave neighs/atom = 78.5245
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  -17493.17      -17493.17      -17641.492     -17641.492      286.9379       286.9379       44081.984      44081.984     -131.9589      -131.9589     
      5000  -17497.707     -17497.707     -17647.398     -17647.398      289.58814      289.58814      44085.139      44085.139     -667.24007     -667.24007    
Loop time of 331.048 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.958 hours/ns, 3.021 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    | 330.16     | 330.16     | 330.16     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14191    | 0.14191    | 0.14191    |   0.0 |  0.04
Output  | 0.0001907  | 0.0001907  | 0.0001907  |   0.0 |  0.00
Modify  | 0.64789    | 0.64789    | 0.64789    |   0.0 |  0.20
Other   |            | 0.0948     |            |       |  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:       314324 ave      314324 max      314324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314324
Ave neighs/atom = 78.581
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 = 291.368171462767, Press = -84.4442943487247
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  -17497.707     -17497.707     -17647.398     -17647.398      289.58814      289.58814      44085.139      44085.139     -667.24007     -667.24007    
      6000  -17492.175     -17492.175     -17645.821     -17645.821      297.23704      297.23704      44091.552      44091.552     -795.75389     -795.75389    
Loop time of 331.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.038 hours/ns, 3.018 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    | 330.43     | 330.43     | 330.43     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14243    | 0.14243    | 0.14243    |   0.0 |  0.04
Output  | 0.00019312 | 0.00019312 | 0.00019312 |   0.0 |  0.00
Modify  | 0.67312    | 0.67312    | 0.67312    |   0.0 |  0.20
Other   |            | 0.09435    |            |       |  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:       314194 ave      314194 max      314194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314194
Ave neighs/atom = 78.5485
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 = 292.792241981536, Press = -31.4752179334508
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  -17492.175     -17492.175     -17645.821     -17645.821      297.23704      297.23704      44091.552      44091.552     -795.75389     -795.75389    
      7000  -17496.996     -17496.996     -17648.657     -17648.657      293.39901      293.39901      44039.465      44039.465      1107.0003      1107.0003    
Loop time of 341.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.908 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.72     | 340.72     | 340.72     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15076    | 0.15076    | 0.15076    |   0.0 |  0.04
Output  | 0.00019337 | 0.00019337 | 0.00019337 |   0.0 |  0.00
Modify  | 0.70766    | 0.70766    | 0.70766    |   0.0 |  0.21
Other   |            | 0.0953     |            |       |  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:       314338 ave      314338 max      314338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314338
Ave neighs/atom = 78.5845
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 = 292.98504742099, Press = -24.1774048366019
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  -17496.996     -17496.996     -17648.657     -17648.657      293.39901      293.39901      44039.465      44039.465      1107.0003      1107.0003    
      8000  -17494.546     -17494.546     -17646.105     -17646.105      293.20093      293.20093      44008.595      44008.595      2646.4543      2646.4543    
Loop time of 331.691 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.136 hours/ns, 3.015 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    | 330.78     | 330.78     | 330.78     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14668    | 0.14668    | 0.14668    |   0.0 |  0.04
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.67277    | 0.67277    | 0.67277    |   0.0 |  0.20
Other   |            | 0.09278    |            |       |  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:       314244 ave      314244 max      314244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314244
Ave neighs/atom = 78.561
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 = 292.868138103164, Press = -1.70128208866827
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  -17494.546     -17494.546     -17646.105     -17646.105      293.20093      293.20093      44008.595      44008.595      2646.4543      2646.4543    
      9000  -17499.301     -17499.301     -17645.678     -17645.678      283.17615      283.17615      44040.17       44040.17       1256.0124      1256.0124    
Loop time of 331.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.052 hours/ns, 3.018 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    | 330.47     | 330.47     | 330.47     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14595    | 0.14595    | 0.14595    |   0.0 |  0.04
Output  | 0.00024245 | 0.00024245 | 0.00024245 |   0.0 |  0.00
Modify  | 0.67262    | 0.67262    | 0.67262    |   0.0 |  0.20
Other   |            | 0.09302    |            |       |  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:       314356 ave      314356 max      314356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314356
Ave neighs/atom = 78.589
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 = 292.39497564225, Press = 7.06558143325552
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  -17499.301     -17499.301     -17645.678     -17645.678      283.17615      283.17615      44040.17       44040.17       1256.0124      1256.0124    
     10000  -17493.168     -17493.168     -17647.038     -17647.038      297.67189      297.67189      44076.922      44076.922     -265.29539     -265.29539    
Loop time of 332.004 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.223 hours/ns, 3.012 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    | 331.09     | 331.09     | 331.09     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14497    | 0.14497    | 0.14497    |   0.0 |  0.04
Output  | 0.00019369 | 0.00019369 | 0.00019369 |   0.0 |  0.00
Modify  | 0.67492    | 0.67492    | 0.67492    |   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:       314244 ave      314244 max      314244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314244
Ave neighs/atom = 78.561
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 = 292.446057432036, Press = 2.43579720338389
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  -17493.168     -17493.168     -17647.038     -17647.038      297.67189      297.67189      44076.922      44076.922     -265.29539     -265.29539    
     11000  -17499.157     -17499.157     -17645.762     -17645.762      283.6161       283.6161       44076.795      44076.795     -260.45472     -260.45472    
Loop time of 330.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.815 hours/ns, 3.025 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.63     | 329.63     | 329.63     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13934    | 0.13934    | 0.13934    |   0.0 |  0.04
Output  | 0.00019185 | 0.00019185 | 0.00019185 |   0.0 |  0.00
Modify  | 0.67032    | 0.67032    | 0.67032    |   0.0 |  0.20
Other   |            | 0.09717    |            |       |  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:       314180 ave      314180 max      314180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314180
Ave neighs/atom = 78.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.282002847791, Press = 2.41869857203639
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  -17499.157     -17499.157     -17645.762     -17645.762      283.6161       283.6161       44076.795      44076.795     -260.45472     -260.45472    
     12000  -17497.402     -17497.402     -17646.844     -17646.844      289.10613      289.10613      44082.203      44082.203     -595.979       -595.979      
Loop time of 330.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.703 hours/ns, 3.029 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.22     | 329.22     | 329.22     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13971    | 0.13971    | 0.13971    |   0.0 |  0.04
Output  | 0.00019139 | 0.00019139 | 0.00019139 |   0.0 |  0.00
Modify  | 0.66776    | 0.66776    | 0.66776    |   0.0 |  0.20
Other   |            | 0.09744    |            |       |  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:       314134 ave      314134 max      314134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314134
Ave neighs/atom = 78.5335
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 = 292.341050259419, Press = -1.57671390056785
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  -17497.402     -17497.402     -17646.844     -17646.844      289.10613      289.10613      44082.203      44082.203     -595.979       -595.979      
     13000  -17492.384     -17492.384     -17647.259     -17647.259      299.61559      299.61559      44087.233      44087.233     -675.51083     -675.51083    
Loop time of 329.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.621 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.93     | 328.93     | 328.93     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13846    | 0.13846    | 0.13846    |   0.0 |  0.04
Output  | 0.0001924  | 0.0001924  | 0.0001924  |   0.0 |  0.00
Modify  | 0.66968    | 0.66968    | 0.66968    |   0.0 |  0.20
Other   |            | 0.09731    |            |       |  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:       314172 ave      314172 max      314172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314172
Ave neighs/atom = 78.543
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 = 292.469523331506, Press = -3.8546077120083
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  -17492.384     -17492.384     -17647.259     -17647.259      299.61559      299.61559      44087.233      44087.233     -675.51083     -675.51083    
     14000  -17497.123     -17497.123     -17647.263     -17647.263      290.45531      290.45531      44039.98       44039.98       1240.449       1240.449     
Loop time of 329.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.640 hours/ns, 3.031 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        | 329        | 329        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13893    | 0.13893    | 0.13893    |   0.0 |  0.04
Output  | 0.00045933 | 0.00045933 | 0.00045933 |   0.0 |  0.00
Modify  | 0.66977    | 0.66977    | 0.66977    |   0.0 |  0.20
Other   |            | 0.09721    |            |       |  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:       314158 ave      314158 max      314158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314158
Ave neighs/atom = 78.5395
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 = 292.602467222297, Press = -4.19417971884869
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  -17497.123     -17497.123     -17647.263     -17647.263      290.45531      290.45531      44039.98       44039.98       1240.449       1240.449     
     15000  -17494.52      -17494.52      -17645.944     -17645.944      292.94051      292.94051      44015.571      44015.571      2315.2731      2315.2731    
Loop time of 329.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.641 hours/ns, 3.031 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        | 329        | 329        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13922    | 0.13922    | 0.13922    |   0.0 |  0.04
Output  | 0.00019538 | 0.00019538 | 0.00019538 |   0.0 |  0.00
Modify  | 0.6697     | 0.6697     | 0.6697     |   0.0 |  0.20
Other   |            | 0.09742    |            |       |  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:       314244 ave      314244 max      314244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314244
Ave neighs/atom = 78.561
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 = 292.62856777063, Press = 0.0634578920913259
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  -17494.52      -17494.52      -17645.944     -17645.944      292.94051      292.94051      44015.571      44015.571      2315.2731      2315.2731    
     16000  -17492.368     -17492.368     -17645.093     -17645.093      295.45618      295.45618      44035.579      44035.579      1691.1044      1691.1044    
Loop time of 330.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.776 hours/ns, 3.027 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.49     | 329.49     | 329.49     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13926    | 0.13926    | 0.13926    |   0.0 |  0.04
Output  | 0.0001944  | 0.0001944  | 0.0001944  |   0.0 |  0.00
Modify  | 0.66972    | 0.66972    | 0.66972    |   0.0 |  0.20
Other   |            | 0.09707    |            |       |  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:       314330 ave      314330 max      314330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314330
Ave neighs/atom = 78.5825
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 = 292.693733605528, Press = 3.60277688318901
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  -17492.368     -17492.368     -17645.093     -17645.093      295.45618      295.45618      44035.579      44035.579      1691.1044      1691.1044    
     17000  -17493.89      -17493.89      -17647.862     -17647.862      297.86913      297.86913      44071.026      44071.026     -43.432188     -43.432188    
Loop time of 330.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.917 hours/ns, 3.022 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.99     | 329.99     | 329.99     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13976    | 0.13976    | 0.13976    |   0.0 |  0.04
Output  | 0.00019134 | 0.00019134 | 0.00019134 |   0.0 |  0.00
Modify  | 0.66965    | 0.66965    | 0.66965    |   0.0 |  0.20
Other   |            | 0.09743    |            |       |  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:       314248 ave      314248 max      314248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314248
Ave neighs/atom = 78.562
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 = 292.917046783872, Press = 3.00236939764661
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  -17493.89      -17493.89      -17647.862     -17647.862      297.86913      297.86913      44071.026      44071.026     -43.432188     -43.432188    
     18000  -17491.828     -17491.828     -17645.282     -17645.282      296.86641      296.86641      44103.111      44103.111     -1120.8913     -1120.8913    
Loop time of 329.81 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.614 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.91     | 328.91     | 328.91     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13861    | 0.13861    | 0.13861    |   0.0 |  0.04
Output  | 0.00019489 | 0.00019489 | 0.00019489 |   0.0 |  0.00
Modify  | 0.6689     | 0.6689     | 0.6689     |   0.0 |  0.20
Other   |            | 0.09661    |            |       |  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:       314116 ave      314116 max      314116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314116
Ave neighs/atom = 78.529
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 = 292.981812594681, Press = 1.67022428398391
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  -17491.828     -17491.828     -17645.282     -17645.282      296.86641      296.86641      44103.111      44103.111     -1120.8913     -1120.8913    
     19000  -17497.28      -17497.28      -17646.08      -17646.08       287.86426      287.86426      44147.408      44147.408     -3183.8192     -3183.8192    
Loop time of 330.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.746 hours/ns, 3.028 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.38     | 329.38     | 329.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13807    | 0.13807    | 0.13807    |   0.0 |  0.04
Output  | 0.00019136 | 0.00019136 | 0.00019136 |   0.0 |  0.00
Modify  | 0.66804    | 0.66804    | 0.66804    |   0.0 |  0.20
Other   |            | 0.09646    |            |       |  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:       314134 ave      314134 max      314134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314134
Ave neighs/atom = 78.5335
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 = 293.11102414698, Press = -1.83528722551357
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  -17497.28      -17497.28      -17646.08      -17646.08       287.86426      287.86426      44147.408      44147.408     -3183.8192     -3183.8192    
     20000  -17488.733     -17488.733     -17643.937     -17643.937      300.25303      300.25303      44109.394      44109.394     -1299.5008     -1299.5008    
Loop time of 329.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.589 hours/ns, 3.033 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.82     | 328.82     | 328.82     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13832    | 0.13832    | 0.13832    |   0.0 |  0.04
Output  | 0.00019397 | 0.00019397 | 0.00019397 |   0.0 |  0.00
Modify  | 0.66921    | 0.66921    | 0.66921    |   0.0 |  0.20
Other   |            | 0.09697    |            |       |  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:       313992 ave      313992 max      313992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 313992
Ave neighs/atom = 78.498
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 = 293.204232186937, Press = -4.42945220453184
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  -17488.733     -17488.733     -17643.937     -17643.937      300.25303      300.25303      44109.394      44109.394     -1299.5008     -1299.5008    
     21000  -17495.574     -17495.574     -17648.196     -17648.196      295.25909      295.25909      44056.26       44056.26       492.1453       492.1453     
Loop time of 330.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.821 hours/ns, 3.025 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.65     | 329.65     | 329.65     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13866    | 0.13866    | 0.13866    |   0.0 |  0.04
Output  | 0.00019513 | 0.00019513 | 0.00019513 |   0.0 |  0.00
Modify  | 0.67019    | 0.67019    | 0.67019    |   0.0 |  0.20
Other   |            | 0.09731    |            |       |  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:       314148 ave      314148 max      314148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314148
Ave neighs/atom = 78.537
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 = 293.281017788636, Press = -1.44760163321239
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  -17495.574     -17495.574     -17648.196     -17648.196      295.25909      295.25909      44056.26       44056.26       492.1453       492.1453     
     22000  -17493.725     -17493.725     -17642.306     -17642.306      287.43911      287.43911      44051.67       44051.67       1120.4204      1120.4204    
Loop time of 330.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.769 hours/ns, 3.027 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.46     | 329.46     | 329.46     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13963    | 0.13963    | 0.13963    |   0.0 |  0.04
Output  | 0.00019377 | 0.00019377 | 0.00019377 |   0.0 |  0.00
Modify  | 0.67166    | 0.67166    | 0.67166    |   0.0 |  0.20
Other   |            | 0.09674    |            |       |  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:       314224 ave      314224 max      314224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314224
Ave neighs/atom = 78.556
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 = 293.283312341068, Press = 0.240418903163156
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  -17493.725     -17493.725     -17642.306     -17642.306      287.43911      287.43911      44051.67       44051.67       1120.4204      1120.4204    
     23000  -17497.543     -17497.543     -17647.947     -17647.947      290.96619      290.96619      44048.12       44048.12       781.49172      781.49172    
Loop time of 330.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.857 hours/ns, 3.024 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.78     | 329.78     | 329.78     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13804    | 0.13804    | 0.13804    |   0.0 |  0.04
Output  | 0.00019385 | 0.00019385 | 0.00019385 |   0.0 |  0.00
Modify  | 0.67045    | 0.67045    | 0.67045    |   0.0 |  0.20
Other   |            | 0.09648    |            |       |  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:       314384 ave      314384 max      314384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314384
Ave neighs/atom = 78.596
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.232590223856, Press = 1.36768688247198
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  -17497.543     -17497.543     -17647.947     -17647.947      290.96619      290.96619      44048.12       44048.12       781.49172      781.49172    
     24000  -17489.636     -17489.636     -17643.106     -17643.106      296.89828      296.89828      44083.049      44083.049     -175.62225     -175.62225    
Loop time of 330.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.917 hours/ns, 3.022 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    | 330        | 330        | 330        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13945    | 0.13945    | 0.13945    |   0.0 |  0.04
Output  | 0.0001927  | 0.0001927  | 0.0001927  |   0.0 |  0.00
Modify  | 0.66974    | 0.66974    | 0.66974    |   0.0 |  0.20
Other   |            | 0.09705    |            |       |  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:       314292 ave      314292 max      314292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314292
Ave neighs/atom = 78.573
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 = 293.282200894323, Press = 3.26432145603998
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  -17489.636     -17489.636     -17643.106     -17643.106      296.89828      296.89828      44083.049      44083.049     -175.62225     -175.62225    
     25000  -17494.136     -17494.136     -17646.935     -17646.935      295.59914      295.59914      44133.146      44133.146     -2553.3972     -2553.3972    
Loop time of 330.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.839 hours/ns, 3.025 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.71     | 329.71     | 329.71     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13922    | 0.13922    | 0.13922    |   0.0 |  0.04
Output  | 0.00019335 | 0.00019335 | 0.00019335 |   0.0 |  0.00
Modify  | 0.67074    | 0.67074    | 0.67074    |   0.0 |  0.20
Other   |            | 0.09628    |            |       |  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:       314178 ave      314178 max      314178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314178
Ave neighs/atom = 78.5445
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 = 293.280671128506, Press = 2.16088085323431
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  -17494.136     -17494.136     -17646.935     -17646.935      295.59914      295.59914      44133.146      44133.146     -2553.3972     -2553.3972    
     26000  -17490.531     -17490.531     -17643.302     -17643.302      295.54548      295.54548      44124.646      44124.646     -1946.304      -1946.304     
Loop time of 359.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.960 hours/ns, 2.779 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    | 358.86     | 358.86     | 358.86     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15007    | 0.15007    | 0.15007    |   0.0 |  0.04
Output  | 0.00019236 | 0.00019236 | 0.00019236 |   0.0 |  0.00
Modify  | 0.74992    | 0.74992    | 0.74992    |   0.0 |  0.21
Other   |            | 0.101      |            |       |  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:       314066 ave      314066 max      314066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314066
Ave neighs/atom = 78.5165
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 = 293.257853331388, Press = -0.505746112788085
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  -17490.531     -17490.531     -17643.302     -17643.302      295.54548      295.54548      44124.646      44124.646     -1946.304      -1946.304     
     27000  -17496.604     -17496.604     -17646.112     -17646.112      289.23279      289.23279      44084.506      44084.506     -591.11424     -591.11424    
Loop time of 341.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.931 hours/ns, 2.926 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.81     | 340.81     | 340.81     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14379    | 0.14379    | 0.14379    |   0.0 |  0.04
Output  | 0.00029776 | 0.00029776 | 0.00029776 |   0.0 |  0.00
Modify  | 0.70065    | 0.70065    | 0.70065    |   0.0 |  0.21
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:       314100 ave      314100 max      314100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314100
Ave neighs/atom = 78.525
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 = 293.250924488472, Press = -1.65664353786314
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  -17496.604     -17496.604     -17646.112     -17646.112      289.23279      289.23279      44084.506      44084.506     -591.11424     -591.11424    
     28000  -17495.335     -17495.335     -17646.618     -17646.618      292.66673      292.66673      44051.488      44051.488      775.0218       775.0218     
Loop time of 338.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.975 hours/ns, 2.956 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    | 337.38     | 337.38     | 337.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14331    | 0.14331    | 0.14331    |   0.0 |  0.04
Output  | 0.00023731 | 0.00023731 | 0.00023731 |   0.0 |  0.00
Modify  | 0.6886     | 0.6886     | 0.6886     |   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:       314208 ave      314208 max      314208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314208
Ave neighs/atom = 78.552
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 = 293.269851326524, Press = -1.20929627608197
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  -17495.335     -17495.335     -17646.618     -17646.618      292.66673      292.66673      44051.488      44051.488      775.0218       775.0218     
     29000  -17491.94      -17491.94      -17645.638     -17645.638      297.3394       297.3394       44031.017      44031.017      1708.9775      1708.9775    
Loop time of 344.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.802 hours/ns, 2.900 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    | 343.93     | 343.93     | 343.93     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1451     | 0.1451     | 0.1451     |   0.0 |  0.04
Output  | 0.00019499 | 0.00019499 | 0.00019499 |   0.0 |  0.00
Modify  | 0.71056    | 0.71056    | 0.71056    |   0.0 |  0.21
Other   |            | 0.09821    |            |       |  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:       314228 ave      314228 max      314228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314228
Ave neighs/atom = 78.557
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 = 293.262158675882, Press = 0.374490270237524
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  -17491.94      -17491.94      -17645.638     -17645.638      297.3394       297.3394       44031.017      44031.017      1708.9775      1708.9775    
     30000  -17495.391     -17495.391     -17647.879     -17647.879      294.99794      294.99794      44040.385      44040.385      1149.2887      1149.2887    
Loop time of 382.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.126 hours/ns, 2.617 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    | 380.97     | 380.97     | 380.97     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15986    | 0.15986    | 0.15986    |   0.0 |  0.04
Output  | 0.00019304 | 0.00019304 | 0.00019304 |   0.0 |  0.00
Modify  | 0.81812    | 0.81812    | 0.81812    |   0.0 |  0.21
Other   |            | 0.1053     |            |       |  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:       314362 ave      314362 max      314362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314362
Ave neighs/atom = 78.5905
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 = 293.258562460484, Press = 1.85083972567196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17495.391     -17495.391     -17647.879     -17647.879      294.99794      294.99794      44040.385      44040.385      1149.2887      1149.2887    
     31000  -17490.852     -17490.852     -17644.279     -17644.279      296.81432      296.81432      44082.798      44082.798     -228.2721      -228.2721     
Loop time of 336.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.352 hours/ns, 2.976 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.14     | 335.14     | 335.14     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14373    | 0.14373    | 0.14373    |   0.0 |  0.04
Output  | 0.00019531 | 0.00019531 | 0.00019531 |   0.0 |  0.00
Modify  | 0.68882    | 0.68882    | 0.68882    |   0.0 |  0.20
Other   |            | 0.09517    |            |       |  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:       314292 ave      314292 max      314292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314292
Ave neighs/atom = 78.573
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 = 293.254566093415, Press = 2.15039352176744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17490.852     -17490.852     -17644.279     -17644.279      296.81432      296.81432      44082.798      44082.798     -228.2721      -228.2721     
     32000  -17494.349     -17494.349     -17645.072     -17645.072      291.58342      291.58342      44104.457      44104.457     -1288.8749     -1288.8749    
Loop time of 332.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.241 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.15     | 331.15     | 331.15     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14358    | 0.14358    | 0.14358    |   0.0 |  0.04
Output  | 0.00024312 | 0.00024312 | 0.00024312 |   0.0 |  0.00
Modify  | 0.67621    | 0.67621    | 0.67621    |   0.0 |  0.20
Other   |            | 0.09355    |            |       |  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:       314200 ave      314200 max      314200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314200
Ave neighs/atom = 78.55
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 = 293.220431073711, Press = 1.17632505704635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17494.349     -17494.349     -17645.072     -17645.072      291.58342      291.58342      44104.457      44104.457     -1288.8749     -1288.8749    
     33000  -17499.357     -17499.357     -17649.617     -17649.617      290.68791      290.68791      44103.761      44103.761     -1660.6036     -1660.6036    
Loop time of 331.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.218 hours/ns, 3.012 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    | 331.07     | 331.07     | 331.07     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14306    | 0.14306    | 0.14306    |   0.0 |  0.04
Output  | 0.00019376 | 0.00019376 | 0.00019376 |   0.0 |  0.00
Modify  | 0.67511    | 0.67511    | 0.67511    |   0.0 |  0.20
Other   |            | 0.09358    |            |       |  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:       314144 ave      314144 max      314144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314144
Ave neighs/atom = 78.536
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 = 293.177317425983, Press = -0.327949187494166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17499.357     -17499.357     -17649.617     -17649.617      290.68791      290.68791      44103.761      44103.761     -1660.6036     -1660.6036    
     34000  -17492.849     -17492.849     -17641.51      -17641.51       287.59524      287.59524      44099.219      44099.219     -832.9453      -832.9453     
Loop time of 331.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.120 hours/ns, 3.015 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    | 330.72     | 330.72     | 330.72     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14367    | 0.14367    | 0.14367    |   0.0 |  0.04
Output  | 0.00019942 | 0.00019942 | 0.00019942 |   0.0 |  0.00
Modify  | 0.6781     | 0.6781     | 0.6781     |   0.0 |  0.20
Other   |            | 0.09285    |            |       |  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:       314078 ave      314078 max      314078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314078
Ave neighs/atom = 78.5195
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 = 293.189369982726, Press = -1.56496438957621
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17492.849     -17492.849     -17641.51      -17641.51       287.59524      287.59524      44099.219      44099.219     -832.9453      -832.9453     
     35000  -17496.288     -17496.288     -17647.59      -17647.59       292.70404      292.70404      44039.254      44039.254      1191.0812      1191.0812    
Loop time of 346.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 96.119 hours/ns, 2.890 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    | 345.07     | 345.07     | 345.07     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14655    | 0.14655    | 0.14655    |   0.0 |  0.04
Output  | 0.0002398  | 0.0002398  | 0.0002398  |   0.0 |  0.00
Modify  | 0.71428    | 0.71428    | 0.71428    |   0.0 |  0.21
Other   |            | 0.09878    |            |       |  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:       314160 ave      314160 max      314160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314160
Ave neighs/atom = 78.54
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 = 293.204070976195, Press = -2.53814775319973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17496.288     -17496.288     -17647.59      -17647.59       292.70404      292.70404      44039.254      44039.254      1191.0812      1191.0812    
     36000  -17499.176     -17499.176     -17651.376     -17651.376      294.44207      294.44207      44018.152      44018.152      1830.0963      1830.0963    
Loop time of 329.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.262 ns/day, 91.595 hours/ns, 3.033 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.83     | 328.83     | 328.83     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13969    | 0.13969    | 0.13969    |   0.0 |  0.04
Output  | 0.00019313 | 0.00019313 | 0.00019313 |   0.0 |  0.00
Modify  | 0.67176    | 0.67176    | 0.67176    |   0.0 |  0.20
Other   |            | 0.09699    |            |       |  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:       314236 ave      314236 max      314236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 314236
Ave neighs/atom = 78.559
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
44070.9061038483

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0