# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ni

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

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


mass          1 ${mass_converted}
mass          1 58.6934

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

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

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

variable temp_converted equal 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_478967255435_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17627.791     -17627.791     -17800         -17800          333.15         333.15         43665.961      43665.961      4212.41        4212.41      
      1000  -17443.869     -17443.869     -17624.378     -17624.378      349.20584      349.20584      44225.061      44225.061     -853.81295     -853.81295    
Loop time of 108.422 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.797 ns/day, 30.117 hours/ns, 9.223 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.26     | 108.26     | 108.26     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02281    | 0.02281    | 0.02281    |   0.0 |  0.02
Output  | 0.000362   | 0.000362   | 0.000362   |   0.0 |  0.00
Modify  | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.11
Other   |            | 0.0121     |            |       |  0.01

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

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

Performance: 0.755 ns/day, 31.777 hours/ns, 8.741 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.24     | 114.24     | 114.24     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02345    | 0.02345    | 0.02345    |   0.0 |  0.02
Output  | 0.00014749 | 0.00014749 | 0.00014749 |   0.0 |  0.00
Modify  | 0.12392    | 0.12392    | 0.12392    |   0.0 |  0.11
Other   |            | 0.01251    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6144 ave        6144 max        6144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540854 ave      540854 max      540854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.755 ns/day, 31.789 hours/ns, 8.738 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.28     | 114.28     | 114.28     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025279   | 0.025279   | 0.025279   |   0.0 |  0.02
Output  | 8.1553e-05 | 8.1553e-05 | 8.1553e-05 |   0.0 |  0.00
Modify  | 0.12667    | 0.12667    | 0.12667    |   0.0 |  0.11
Other   |            | 0.01278    |            |       |  0.01

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

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

Performance: 0.754 ns/day, 31.813 hours/ns, 8.731 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.37     | 114.37     | 114.37     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024874   | 0.024874   | 0.024874   |   0.0 |  0.02
Output  | 8.4669e-05 | 8.4669e-05 | 8.4669e-05 |   0.0 |  0.00
Modify  | 0.12579    | 0.12579    | 0.12579    |   0.0 |  0.11
Other   |            | 0.01261    |            |       |  0.01

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

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

Performance: 0.756 ns/day, 31.752 hours/ns, 8.748 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.15     | 114.15     | 114.15     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024499   | 0.024499   | 0.024499   |   0.0 |  0.02
Output  | 0.00012539 | 0.00012539 | 0.00012539 |   0.0 |  0.00
Modify  | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.11
Other   |            | 0.01242    |            |       |  0.01

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

Total # of neighbors = 540982
Ave neighs/atom = 135.2455
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 = 330.186925099788, Press = -457.136303953603
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17455.811     -17455.811     -17624.511     -17624.511      326.36331      326.36331      44199.096      44199.096      24.891916      24.891916    
      6000  -17449.586     -17449.586     -17623.112     -17623.112      335.69746      335.69746      44248.817      44248.817     -1803.0247     -1803.0247    
Loop time of 114.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.840 hours/ns, 8.724 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.46     | 114.46     | 114.46     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024426   | 0.024426   | 0.024426   |   0.0 |  0.02
Output  | 0.00013465 | 0.00013465 | 0.00013465 |   0.0 |  0.00
Modify  | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.11
Other   |            | 0.01248    |            |       |  0.01

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

Total # of neighbors = 540800
Ave neighs/atom = 135.2
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 = 332.693656180751, Press = -17.2364915495649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17449.586     -17449.586     -17623.112     -17623.112      335.69746      335.69746      44248.817      44248.817     -1803.0247     -1803.0247    
      7000  -17455.624     -17455.624     -17627.618     -17627.618      332.73397      332.73397      44179.77       44179.77       565.99744      565.99744    
Loop time of 114.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.768 hours/ns, 8.744 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.2      | 114.2      | 114.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025491   | 0.025491   | 0.025491   |   0.0 |  0.02
Output  | 0.00010581 | 0.00010581 | 0.00010581 |   0.0 |  0.00
Modify  | 0.13122    | 0.13122    | 0.13122    |   0.0 |  0.11
Other   |            | 0.01275    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540782 ave      540782 max      540782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540782
Ave neighs/atom = 135.1955
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 = 332.97938236992, Press = 29.8156631470425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17455.624     -17455.624     -17627.618     -17627.618      332.73397      332.73397      44179.77       44179.77       565.99744      565.99744    
      8000  -17451.898     -17451.898     -17625.065     -17625.065      335.00257      335.00257      44135.688      44135.688      2684.7642      2684.7642    
Loop time of 114.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.828 hours/ns, 8.727 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.41     | 114.41     | 114.41     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024832   | 0.024832   | 0.024832   |   0.0 |  0.02
Output  | 4.8681e-05 | 4.8681e-05 | 4.8681e-05 |   0.0 |  0.00
Modify  | 0.13088    | 0.13088    | 0.13088    |   0.0 |  0.11
Other   |            | 0.01264    |            |       |  0.01

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

Total # of neighbors = 540834
Ave neighs/atom = 135.2085
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 = 332.926839443777, Press = -9.08733319672548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17451.898     -17451.898     -17625.065     -17625.065      335.00257      335.00257      44135.688      44135.688      2684.7642      2684.7642    
      9000  -17456.684     -17456.684     -17628.358     -17628.358      332.11505      332.11505      44195.006      44195.006     -156.43531     -156.43531    
Loop time of 114.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.849 hours/ns, 8.722 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.48     | 114.48     | 114.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025808   | 0.025808   | 0.025808   |   0.0 |  0.02
Output  | 9.0209e-05 | 9.0209e-05 | 9.0209e-05 |   0.0 |  0.00
Modify  | 0.13241    | 0.13241    | 0.13241    |   0.0 |  0.12
Other   |            | 0.01282    |            |       |  0.01

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

Total # of neighbors = 541142
Ave neighs/atom = 135.2855
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 = 332.605833558688, Press = -14.2747787907671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17456.684     -17456.684     -17628.358     -17628.358      332.11505      332.11505      44195.006      44195.006     -156.43531     -156.43531    
     10000  -17452.312     -17452.312     -17623.316     -17623.316      330.81866      330.81866      44217.769      44217.769     -676.64583     -676.64583    
Loop time of 114.71 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.864 hours/ns, 8.718 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.54     | 114.54     | 114.54     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024827   | 0.024827   | 0.024827   |   0.0 |  0.02
Output  | 0.00012667 | 0.00012667 | 0.00012667 |   0.0 |  0.00
Modify  | 0.13014    | 0.13014    | 0.13014    |   0.0 |  0.11
Other   |            | 0.01242    |            |       |  0.01

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

Total # of neighbors = 540796
Ave neighs/atom = 135.199
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 = 332.757072453767, Press = -3.69136604557195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17452.312     -17452.312     -17623.316     -17623.316      330.81866      330.81866      44217.769      44217.769     -676.64583     -676.64583    
     11000  -17457.389     -17457.389     -17627.562     -17627.562      329.21129      329.21129      44188.626      44188.626      59.219916      59.219916    
Loop time of 114.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.853 hours/ns, 8.721 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.5      | 114.5      | 114.5      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02514    | 0.02514    | 0.02514    |   0.0 |  0.02
Output  | 5.6416e-05 | 5.6416e-05 | 5.6416e-05 |   0.0 |  0.00
Modify  | 0.13132    | 0.13132    | 0.13132    |   0.0 |  0.11
Other   |            | 0.01274    |            |       |  0.01

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

Total # of neighbors = 540960
Ave neighs/atom = 135.24
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 = 333.000114196523, Press = -1.13016003434874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17457.389     -17457.389     -17627.562     -17627.562      329.21129      329.21129      44188.626      44188.626      59.219916      59.219916    
     12000  -17454.023     -17454.023     -17626.767     -17626.767      334.18497      334.18497      44156.71       44156.71       1604.452       1604.452     
Loop time of 114.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.848 hours/ns, 8.722 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.48     | 114.48     | 114.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024517   | 0.024517   | 0.024517   |   0.0 |  0.02
Output  | 5.1036e-05 | 5.1036e-05 | 5.1036e-05 |   0.0 |  0.00
Modify  | 0.13031    | 0.13031    | 0.13031    |   0.0 |  0.11
Other   |            | 0.01258    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541068 ave      541068 max      541068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541068
Ave neighs/atom = 135.267
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 = 332.948518076576, Press = -2.28746044473521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17454.023     -17454.023     -17626.767     -17626.767      334.18497      334.18497      44156.71       44156.71       1604.452       1604.452     
     13000  -17452.456     -17452.456     -17620.794     -17620.794      325.66173      325.66173      44201.931      44201.931      281.15931      281.15931    
Loop time of 114.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.785 hours/ns, 8.739 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.26     | 114.26     | 114.26     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025012   | 0.025012   | 0.025012   |   0.0 |  0.02
Output  | 0.00011017 | 0.00011017 | 0.00011017 |   0.0 |  0.00
Modify  | 0.13086    | 0.13086    | 0.13086    |   0.0 |  0.11
Other   |            | 0.0126     |            |       |  0.01

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

Total # of neighbors = 541162
Ave neighs/atom = 135.2905
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 = 332.693873757156, Press = -11.5214946289442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17452.456     -17452.456     -17620.794     -17620.794      325.66173      325.66173      44201.931      44201.931      281.15931      281.15931    
     14000  -17458.594     -17458.594     -17626.778     -17626.778      325.36416      325.36416      44248.167      44248.167     -2250.8083     -2250.8083    
Loop time of 114.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.848 hours/ns, 8.722 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.48     | 114.48     | 114.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025083   | 0.025083   | 0.025083   |   0.0 |  0.02
Output  | 0.00014203 | 0.00014203 | 0.00014203 |   0.0 |  0.00
Modify  | 0.1312     | 0.1312     | 0.1312     |   0.0 |  0.11
Other   |            | 0.01268    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6140 ave        6140 max        6140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540904 ave      540904 max      540904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.753 ns/day, 31.853 hours/ns, 8.721 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.5      | 114.5      | 114.5      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025084   | 0.025084   | 0.025084   |   0.0 |  0.02
Output  | 5.4171e-05 | 5.4171e-05 | 5.4171e-05 |   0.0 |  0.00
Modify  | 0.13136    | 0.13136    | 0.13136    |   0.0 |  0.11
Other   |            | 0.0127     |            |       |  0.01

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

Total # of neighbors = 540728
Ave neighs/atom = 135.182
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 = 332.669913037975, Press = 1.76219380878293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17451.531     -17451.531     -17623.064     -17623.064      331.84199      331.84199      44186.345      44186.345      781.9231       781.9231     
     16000  -17448.832     -17448.832     -17623.798     -17623.798      338.48204      338.48204      44197.009      44197.009      366.0313       366.0313     
Loop time of 114.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.879 hours/ns, 8.713 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.6      | 114.6      | 114.6      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024803   | 0.024803   | 0.024803   |   0.0 |  0.02
Output  | 0.0001245  | 0.0001245  | 0.0001245  |   0.0 |  0.00
Modify  | 0.13075    | 0.13075    | 0.13075    |   0.0 |  0.11
Other   |            | 0.01256    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6128 ave        6128 max        6128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541040 ave      541040 max      541040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541040
Ave neighs/atom = 135.26
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 = 332.697547940238, Press = -2.51274593899307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17448.832     -17448.832     -17623.798     -17623.798      338.48204      338.48204      44197.009      44197.009      366.0313       366.0313     
     17000  -17451.375     -17451.375     -17623.602     -17623.602      333.18452      333.18452      44203.532      44203.532     -1.3831232     -1.3831232    
Loop time of 114.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.815 hours/ns, 8.731 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.36     | 114.36     | 114.36     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026168   | 0.026168   | 0.026168   |   0.0 |  0.02
Output  | 4.9433e-05 | 4.9433e-05 | 4.9433e-05 |   0.0 |  0.00
Modify  | 0.13243    | 0.13243    | 0.13243    |   0.0 |  0.12
Other   |            | 0.01281    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6157 ave        6157 max        6157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540996 ave      540996 max      540996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.754 ns/day, 31.823 hours/ns, 8.729 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.39     | 114.39     | 114.39     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024821   | 0.024821   | 0.024821   |   0.0 |  0.02
Output  | 5.827e-05  | 5.827e-05  | 5.827e-05  |   0.0 |  0.00
Modify  | 0.13105    | 0.13105    | 0.13105    |   0.0 |  0.11
Other   |            | 0.0125     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6106 ave        6106 max        6106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541058 ave      541058 max      541058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.754 ns/day, 31.821 hours/ns, 8.730 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.39     | 114.39     | 114.39     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025089   | 0.025089   | 0.025089   |   0.0 |  0.02
Output  | 0.00011961 | 0.00011961 | 0.00011961 |   0.0 |  0.00
Modify  | 0.13054    | 0.13054    | 0.13054    |   0.0 |  0.11
Other   |            | 0.01253    |            |       |  0.01

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

Total # of neighbors = 540990
Ave neighs/atom = 135.2475
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 = 332.530904062001, Press = -2.03589603209328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17454.059     -17454.059     -17623.367     -17623.367      327.53873      327.53873      44197.783      44197.783      130.5134       130.5134     
     20000  -17452.68      -17452.68      -17625.254     -17625.254      333.85691      333.85691      44197.154      44197.154      88.835098      88.835098    
Loop time of 114.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.828 hours/ns, 8.727 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.41     | 114.41     | 114.41     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025426   | 0.025426   | 0.025426   |   0.0 |  0.02
Output  | 5.5434e-05 | 5.5434e-05 | 5.5434e-05 |   0.0 |  0.00
Modify  | 0.13186    | 0.13186    | 0.13186    |   0.0 |  0.12
Other   |            | 0.01256    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6145 ave        6145 max        6145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541016 ave      541016 max      541016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541016
Ave neighs/atom = 135.254
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 = 332.574143729842, Press = -2.22029559045436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17452.68      -17452.68      -17625.254     -17625.254      333.85691      333.85691      44197.154      44197.154      88.835098      88.835098    
     21000  -17452.146     -17452.146     -17625.724     -17625.724      335.7978       335.7978       44220.245      44220.245     -971.38072     -971.38072    
Loop time of 114.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.696 hours/ns, 8.764 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.94     | 113.94     | 113.94     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024532   | 0.024532   | 0.024532   |   0.0 |  0.02
Output  | 0.00015348 | 0.00015348 | 0.00015348 |   0.0 |  0.00
Modify  | 0.13022    | 0.13022    | 0.13022    |   0.0 |  0.11
Other   |            | 0.01267    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541042 ave      541042 max      541042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541042
Ave neighs/atom = 135.2605
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 = 332.678766386944, Press = -2.61409964044059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17452.146     -17452.146     -17625.724     -17625.724      335.7978       335.7978       44220.245      44220.245     -971.38072     -971.38072    
     22000  -17449.067     -17449.067     -17620.356     -17620.356      331.36988      331.36988      44236.655      44236.655     -1131.0097     -1131.0097    
Loop time of 114.695 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.860 hours/ns, 8.719 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.53     | 114.53     | 114.53     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025365   | 0.025365   | 0.025365   |   0.0 |  0.02
Output  | 6.3209e-05 | 6.3209e-05 | 6.3209e-05 |   0.0 |  0.00
Modify  | 0.13104    | 0.13104    | 0.13104    |   0.0 |  0.11
Other   |            | 0.01255    |            |       |  0.01

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

Total # of neighbors = 540856
Ave neighs/atom = 135.214
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 = 332.763441315818, Press = 0.872896992884366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17449.067     -17449.067     -17620.356     -17620.356      331.36988      331.36988      44236.655      44236.655     -1131.0097     -1131.0097    
     23000  -17456.186     -17456.186     -17626.357     -17626.357      329.20826      329.20826      44150.38       44150.38       1834.8958      1834.8958    
Loop time of 114.36 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.767 hours/ns, 8.744 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.2      | 114.2      | 114.2      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022761   | 0.022761   | 0.022761   |   0.0 |  0.02
Output  | 4.9803e-05 | 4.9803e-05 | 4.9803e-05 |   0.0 |  0.00
Modify  | 0.12595    | 0.12595    | 0.12595    |   0.0 |  0.11
Other   |            | 0.01134    |            |       |  0.01

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

Total # of neighbors = 540922
Ave neighs/atom = 135.2305
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 = 332.847284456229, Press = 0.765099170399224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17456.186     -17456.186     -17626.357     -17626.357      329.20826      329.20826      44150.38       44150.38       1834.8958      1834.8958    
     24000  -17450.799     -17450.799     -17623.005     -17623.005      333.14553      333.14553      44175.446      44175.446      1157.9049      1157.9049    
Loop time of 114.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.704 hours/ns, 8.762 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.97     | 113.97     | 113.97     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02288    | 0.02288    | 0.02288    |   0.0 |  0.02
Output  | 6.372e-05  | 6.372e-05  | 6.372e-05  |   0.0 |  0.00
Modify  | 0.12377    | 0.12377    | 0.12377    |   0.0 |  0.11
Other   |            | 0.01142    |            |       |  0.01

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

Total # of neighbors = 541178
Ave neighs/atom = 135.2945
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 = 332.903364821311, Press = -3.58487996528931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17450.799     -17450.799     -17623.005     -17623.005      333.14553      333.14553      44175.446      44175.446      1157.9049      1157.9049    
     25000  -17447.757     -17447.757     -17624.723     -17624.723      342.351        342.351        44246.737      44246.737     -1870.1028     -1870.1028    
Loop time of 113.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.658 hours/ns, 8.774 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.81     | 113.81     | 113.81     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022633   | 0.022633   | 0.022633   |   0.0 |  0.02
Output  | 7.0232e-05 | 7.0232e-05 | 7.0232e-05 |   0.0 |  0.00
Modify  | 0.12358    | 0.12358    | 0.12358    |   0.0 |  0.11
Other   |            | 0.0114     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6103 ave        6103 max        6103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541004 ave      541004 max      541004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.758 ns/day, 31.650 hours/ns, 8.776 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.78     | 113.78     | 113.78     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022606   | 0.022606   | 0.022606   |   0.0 |  0.02
Output  | 6.925e-05  | 6.925e-05  | 6.925e-05  |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.11
Other   |            | 0.0114     |            |       |  0.01

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

Total # of neighbors = 540632
Ave neighs/atom = 135.158
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 = 332.962022464107, Press = -0.350853180830988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17452.678     -17452.678     -17628.227     -17628.227      339.61075      339.61075      44216.405      44216.405     -1025.086      -1025.086     
     27000  -17456.725     -17456.725     -17626.302     -17626.302      328.05898      328.05898      44178.566      44178.566      712.74169      712.74169    
Loop time of 113.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.635 hours/ns, 8.781 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.73     | 113.73     | 113.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02289    | 0.02289    | 0.02289    |   0.0 |  0.02
Output  | 6.1495e-05 | 6.1495e-05 | 6.1495e-05 |   0.0 |  0.00
Modify  | 0.1237     | 0.1237     | 0.1237     |   0.0 |  0.11
Other   |            | 0.01141    |            |       |  0.01

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

Total # of neighbors = 540704
Ave neighs/atom = 135.176
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 = 332.984181979999, Press = -0.912201450587906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17456.725     -17456.725     -17626.302     -17626.302      328.05898      328.05898      44178.566      44178.566      712.74169      712.74169    
     28000  -17448.83      -17448.83      -17624.642     -17624.642      340.11877      340.11877      44207.043      44207.043     -141.87413     -141.87413    
Loop time of 114.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.677 hours/ns, 8.769 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.88     | 113.88     | 113.88     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02266    | 0.02266    | 0.02266    |   0.0 |  0.02
Output  | 6.6625e-05 | 6.6625e-05 | 6.6625e-05 |   0.0 |  0.00
Modify  | 0.12435    | 0.12435    | 0.12435    |   0.0 |  0.11
Other   |            | 0.01127    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6088 ave        6088 max        6088 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540958 ave      540958 max      540958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.757 ns/day, 31.687 hours/ns, 8.766 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.92     | 113.92     | 113.92     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022637   | 0.022637   | 0.022637   |   0.0 |  0.02
Output  | 5.9262e-05 | 5.9262e-05 | 5.9262e-05 |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.11
Other   |            | 0.01137    |            |       |  0.01

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

Total # of neighbors = 540876
Ave neighs/atom = 135.219
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 = 333.002670583351, Press = -1.22425357973134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17452.908     -17452.908     -17625.813     -17625.813      334.49639      334.49639      44206.311      44206.311     -337.55229     -337.55229    
     30000  -17456.317     -17456.317     -17626.986     -17626.986      330.17078      330.17078      44193.751      44193.751     -29.116997     -29.116997    
Loop time of 114.099 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.694 hours/ns, 8.764 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.94     | 113.94     | 113.94     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02254    | 0.02254    | 0.02254    |   0.0 |  0.02
Output  | 6.6054e-05 | 6.6054e-05 | 6.6054e-05 |   0.0 |  0.00
Modify  | 0.12339    | 0.12339    | 0.12339    |   0.0 |  0.11
Other   |            | 0.01124    |            |       |  0.01

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

Total # of neighbors = 540814
Ave neighs/atom = 135.2035
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 = 333.028947588326, Press = -1.35915737660695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17456.317     -17456.317     -17626.986     -17626.986      330.17078      330.17078      44193.751      44193.751     -29.116997     -29.116997    
     31000  -17449.55      -17449.55      -17624.181     -17624.181      337.83553      337.83553      44208.884      44208.884     -281.43269     -281.43269    
Loop time of 114.166 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.713 hours/ns, 8.759 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.01     | 114.01     | 114.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023286   | 0.023286   | 0.023286   |   0.0 |  0.02
Output  | 5.3811e-05 | 5.3811e-05 | 5.3811e-05 |   0.0 |  0.00
Modify  | 0.12549    | 0.12549    | 0.12549    |   0.0 |  0.11
Other   |            | 0.01167    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6131 ave        6131 max        6131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540870 ave      540870 max      540870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.754 ns/day, 31.845 hours/ns, 8.723 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.48     | 114.48     | 114.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024811   | 0.024811   | 0.024811   |   0.0 |  0.02
Output  | 0.00010508 | 0.00010508 | 0.00010508 |   0.0 |  0.00
Modify  | 0.13053    | 0.13053    | 0.13053    |   0.0 |  0.11
Other   |            | 0.01235    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6100 ave        6100 max        6100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540890 ave      540890 max      540890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.753 ns/day, 31.854 hours/ns, 8.720 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    | 114.51     | 114.51     | 114.51     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024868   | 0.024868   | 0.024868   |   0.0 |  0.02
Output  | 0.00014091 | 0.00014091 | 0.00014091 |   0.0 |  0.00
Modify  | 0.13075    | 0.13075    | 0.13075    |   0.0 |  0.11
Other   |            | 0.01255    |            |       |  0.01

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

Total # of neighbors = 540990
Ave neighs/atom = 135.2475
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 = 333.018776270072, Press = -1.09850821208378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17455.912     -17455.912     -17627.058     -17627.058      331.09332      331.09332      44164.137      44164.137      1204.2866      1204.2866    
     34000  -17449.333     -17449.333     -17620.567     -17620.567      331.26379      331.26379      44205.027      44205.027      234.5884       234.5884     
Loop time of 114.983 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.940 hours/ns, 8.697 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    | 114.82     | 114.82     | 114.82     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024094   | 0.024094   | 0.024094   |   0.0 |  0.02
Output  | 5.4562e-05 | 5.4562e-05 | 5.4562e-05 |   0.0 |  0.00
Modify  | 0.13       | 0.13       | 0.13       |   0.0 |  0.11
Other   |            | 0.01236    |            |       |  0.01

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

Total # of neighbors = 541006
Ave neighs/atom = 135.2515
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 = 333.05117166842, Press = -3.34320929551148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17449.333     -17449.333     -17620.567     -17620.567      331.26379      331.26379      44205.027      44205.027      234.5884       234.5884     
     35000  -17450.741     -17450.741     -17622.901     -17622.901      333.0546       333.0546       44268.633      44268.633     -2669.6617     -2669.6617    
Loop time of 114.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.923 hours/ns, 8.702 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    | 114.76     | 114.76     | 114.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023979   | 0.023979   | 0.023979   |   0.0 |  0.02
Output  | 0.00010606 | 0.00010606 | 0.00010606 |   0.0 |  0.00
Modify  | 0.12882    | 0.12882    | 0.12882    |   0.0 |  0.11
Other   |            | 0.01219    |            |       |  0.01

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

Total # of neighbors = 540852
Ave neighs/atom = 135.213
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 = 333.068809009163, Press = -1.28949537105934
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17450.741     -17450.741     -17622.901     -17622.901      333.0546       333.0546       44268.633      44268.633     -2669.6617     -2669.6617    
     36000  -17453.895     -17453.895     -17626.683     -17626.683      334.26996      334.26996      44192.823      44192.823      17.259969      17.259969    
Loop time of 115.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 32.006 hours/ns, 8.679 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.05     | 115.05     | 115.05     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024918   | 0.024918   | 0.024918   |   0.0 |  0.02
Output  | 6.0554e-05 | 6.0554e-05 | 6.0554e-05 |   0.0 |  0.00
Modify  | 0.131      | 0.131      | 0.131      |   0.0 |  0.11
Other   |            | 0.01256    |            |       |  0.01

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

Total # of neighbors = 540654
Ave neighs/atom = 135.1635
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 = 333.10759598668, Press = 0.399580820832554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17453.895     -17453.895     -17626.683     -17626.683      334.26996      334.26996      44192.823      44192.823      17.259969      17.259969    
     37000  -17443.378     -17443.378     -17620.988     -17620.988      343.59828      343.59828      44198.637      44198.637      478.2919       478.2919     
Loop time of 115.069 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.964 hours/ns, 8.690 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.9      | 114.9      | 114.9      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025419   | 0.025419   | 0.025419   |   0.0 |  0.02
Output  | 7.6203e-05 | 7.6203e-05 | 7.6203e-05 |   0.0 |  0.00
Modify  | 0.13158    | 0.13158    | 0.13158    |   0.0 |  0.11
Other   |            | 0.01256    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6159 ave        6159 max        6159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540996 ave      540996 max      540996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.750 ns/day, 32.013 hours/ns, 8.677 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.08     | 115.08     | 115.08     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024621   | 0.024621   | 0.024621   |   0.0 |  0.02
Output  | 5.7268e-05 | 5.7268e-05 | 5.7268e-05 |   0.0 |  0.00
Modify  | 0.13091    | 0.13091    | 0.13091    |   0.0 |  0.11
Other   |            | 0.01254    |            |       |  0.01

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

Total # of neighbors = 541024
Ave neighs/atom = 135.256
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 = 333.202827618841, Press = -1.4880238235302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17453.721     -17453.721     -17625.12      -17625.12       331.5836       331.5836       44202.869      44202.869     -304.19297     -304.19297    
     39000  -17449.168     -17449.168     -17622.234     -17622.234      334.80899      334.80899      44225.016      44225.016     -815.90463     -815.90463    
Loop time of 115.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.991 hours/ns, 8.683 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    | 115        | 115        | 115        |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024195   | 0.024195   | 0.024195   |   0.0 |  0.02
Output  | 5.4612e-05 | 5.4612e-05 | 5.4612e-05 |   0.0 |  0.00
Modify  | 0.12949    | 0.12949    | 0.12949    |   0.0 |  0.11
Other   |            | 0.01229    |            |       |  0.01

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

Total # of neighbors = 540918
Ave neighs/atom = 135.2295
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 = 333.195199076766, Press = -0.562850818463259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17449.168     -17449.168     -17622.234     -17622.234      334.80899      334.80899      44225.016      44225.016     -815.90463     -815.90463    
     40000  -17453.326     -17453.326     -17626.91      -17626.91       335.8097       335.8097       44174.221      44174.221      820.87129      820.87129    
Loop time of 115.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.945 hours/ns, 8.696 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    | 114.83     | 114.83     | 114.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024304   | 0.024304   | 0.024304   |   0.0 |  0.02
Output  | 5.3731e-05 | 5.3731e-05 | 5.3731e-05 |   0.0 |  0.00
Modify  | 0.12934    | 0.12934    | 0.12934    |   0.0 |  0.11
Other   |            | 0.01246    |            |       |  0.01

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

Total # of neighbors = 540844
Ave neighs/atom = 135.211
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 = 333.185549569294, Press = 0.250716178629693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17453.326     -17453.326     -17626.91      -17626.91       335.8097       335.8097       44174.221      44174.221      820.87129      820.87129    
     41000  -17451.054     -17451.054     -17626.411     -17626.411      339.23908      339.23908      44147.439      44147.439      1990.029       1990.029     
Loop time of 115.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.990 hours/ns, 8.683 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    | 115        | 115        | 115        |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024489   | 0.024489   | 0.024489   |   0.0 |  0.02
Output  | 5.2118e-05 | 5.2118e-05 | 5.2118e-05 |   0.0 |  0.00
Modify  | 0.13027    | 0.13027    | 0.13027    |   0.0 |  0.11
Other   |            | 0.01257    |            |       |  0.01

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

Total # of neighbors = 541010
Ave neighs/atom = 135.2525
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 = 333.151100566966, Press = -1.85477123176541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17451.054     -17451.054     -17626.411     -17626.411      339.23908      339.23908      44147.439      44147.439      1990.029       1990.029     
     42000  -17459.958     -17459.958     -17627.53      -17627.53       324.17957      324.17957      44209.964      44209.964     -823.81302     -823.81302    
Loop time of 115.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.965 hours/ns, 8.690 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    | 114.91     | 114.91     | 114.91     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02417    | 0.02417    | 0.02417    |   0.0 |  0.02
Output  | 5.7618e-05 | 5.7618e-05 | 5.7618e-05 |   0.0 |  0.00
Modify  | 0.12965    | 0.12965    | 0.12965    |   0.0 |  0.11
Other   |            | 0.01251    |            |       |  0.01

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

Total # of neighbors = 541196
Ave neighs/atom = 135.299
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 = 333.099791582195, Press = -2.31337154816059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17459.958     -17459.958     -17627.53      -17627.53       324.17957      324.17957      44209.964      44209.964     -823.81302     -823.81302    
     43000  -17452.116     -17452.116     -17625.169     -17625.169      334.7828       334.7828       44230.698      44230.698     -1396.3868     -1396.3868    
Loop time of 115.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.971 hours/ns, 8.688 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    | 114.93     | 114.93     | 114.93     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025024   | 0.025024   | 0.025024   |   0.0 |  0.02
Output  | 5.2168e-05 | 5.2168e-05 | 5.2168e-05 |   0.0 |  0.00
Modify  | 0.13156    | 0.13156    | 0.13156    |   0.0 |  0.11
Other   |            | 0.01256    |            |       |  0.01

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

Total # of neighbors = 540822
Ave neighs/atom = 135.2055
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 = 333.083139811538, Press = -0.368929171546342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17452.116     -17452.116     -17625.169     -17625.169      334.7828       334.7828       44230.698      44230.698     -1396.3868     -1396.3868    
     44000  -17456.688     -17456.688     -17627.196     -17627.196      329.85975      329.85975      44170.442      44170.442      897.87023      897.87023    
Loop time of 114.963 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.934 hours/ns, 8.698 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    | 114.8      | 114.8      | 114.8      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024213   | 0.024213   | 0.024213   |   0.0 |  0.02
Output  | 5.8199e-05 | 5.8199e-05 | 5.8199e-05 |   0.0 |  0.00
Modify  | 0.12968    | 0.12968    | 0.12968    |   0.0 |  0.11
Other   |            | 0.01254    |            |       |  0.01

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

Total # of neighbors = 540892
Ave neighs/atom = 135.223
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
44198.2792256595

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0