# 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.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133157 36.133157 36.133157)
  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 (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuMo__MO_380272712420_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 293.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_380272712420_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14008.467     -14008.467     -14160         -14160          293.15         293.15         47175.631      47175.631      3430.9087      3430.9087    
      1000  -13849.002     -13849.002     -14003.684     -14003.684      299.24183      299.24183      48019.328      48019.328     -2367.742      -2367.742     
Loop time of 100.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.856 ns/day, 28.041 hours/ns, 9.906 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.78     | 100.78     | 100.78     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030521   | 0.030521   | 0.030521   |   0.0 |  0.03
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.12286    | 0.12286    | 0.12286    |   0.0 |  0.12
Other   |            | 0.0127     |            |       |  0.01

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

Total # of neighbors = 704000
Ave neighs/atom = 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 = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13849.002     -13849.002     -14003.684     -14003.684      299.24183      299.24183      48019.328      48019.328     -2367.742      -2367.742     
      2000  -13859.305     -13859.305     -14012.236     -14012.236      295.85458      295.85458      47901.143      47901.143      142.63091      142.63091    
Loop time of 105.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.397 hours/ns, 9.449 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    | 105.67     | 105.67     | 105.67     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030128   | 0.030128   | 0.030128   |   0.0 |  0.03
Output  | 9.4026e-05 | 9.4026e-05 | 9.4026e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.11
Other   |            | 0.01286    |            |       |  0.01

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

Total # of neighbors = 715276
Ave neighs/atom = 178.819
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13859.305     -13859.305     -14012.236     -14012.236      295.85458      295.85458      47901.143      47901.143      142.63091      142.63091    
      3000  -13856.435     -13856.435     -14011.373     -14011.373      299.73785      299.73785      47942.165      47942.165     -746.16561     -746.16561    
Loop time of 106.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.475 hours/ns, 9.424 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    | 105.95     | 105.95     | 105.95     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030058   | 0.030058   | 0.030058   |   0.0 |  0.03
Output  | 0.00010263 | 0.00010263 | 0.00010263 |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  0.11
Other   |            | 0.01283    |            |       |  0.01

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

Total # of neighbors = 716374
Ave neighs/atom = 179.0935
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13856.435     -13856.435     -14011.373     -14011.373      299.73785      299.73785      47942.165      47942.165     -746.16561     -746.16561    
      4000  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.4958      -455.4958     
Loop time of 106.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.448 hours/ns, 9.433 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    | 105.85     | 105.85     | 105.85     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031457   | 0.031457   | 0.031457   |   0.0 |  0.03
Output  | 8.4338e-05 | 8.4338e-05 | 8.4338e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.11
Other   |            | 0.01284    |            |       |  0.01

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

Total # of neighbors = 715264
Ave neighs/atom = 178.816
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13856.343     -13856.343     -14007.995     -14007.995      293.38063      293.38063      47939.837      47939.837     -455.4958      -455.4958     
      5000  -13859.978     -13859.978     -14007.154     -14007.154      284.72244      284.72244      47898.374      47898.374      826.36533      826.36533    
Loop time of 106.099 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.472 hours/ns, 9.425 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    | 105.93     | 105.93     | 105.93     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030022   | 0.030022   | 0.030022   |   0.0 |  0.03
Output  | 6.5383e-05 | 6.5383e-05 | 6.5383e-05 |   0.0 |  0.00
Modify  | 0.12222    | 0.12222    | 0.12222    |   0.0 |  0.12
Other   |            | 0.01285    |            |       |  0.01

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

Total # of neighbors = 715958
Ave neighs/atom = 178.9895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.810507109294, Press = 334.94936907089
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13859.978     -13859.978     -14007.154     -14007.154      284.72244      284.72244      47898.374      47898.374      826.36533      826.36533    
      6000  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92565     -939.92565    
Loop time of 105.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.443 hours/ns, 9.434 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    | 105.83     | 105.83     | 105.83     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030113   | 0.030113   | 0.030113   |   0.0 |  0.03
Output  | 6.7256e-05 | 6.7256e-05 | 6.7256e-05 |   0.0 |  0.00
Modify  | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.12
Other   |            | 0.01285    |            |       |  0.01

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

Total # of neighbors = 716176
Ave neighs/atom = 179.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.542087624685, Press = -15.912351660514
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13853.348     -13853.348     -14008.924     -14008.924      300.97202      300.97202      47960.439      47960.439     -939.92565     -939.92565    
      7000  -13859.988     -13859.988     -14009.647     -14009.647      289.52612      289.52612      47858.292      47858.292      1789.3833      1789.3833    
Loop time of 106.013 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.448 hours/ns, 9.433 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    | 105.84     | 105.84     | 105.84     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030046   | 0.030046   | 0.030046   |   0.0 |  0.03
Output  | 7.0092e-05 | 7.0092e-05 | 7.0092e-05 |   0.0 |  0.00
Modify  | 0.12678    | 0.12678    | 0.12678    |   0.0 |  0.12
Other   |            | 0.01291    |            |       |  0.01

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

Total # of neighbors = 715308
Ave neighs/atom = 178.827
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.973492008164, Press = 30.9873592207573
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13859.988     -13859.988     -14009.647     -14009.647      289.52612      289.52612      47858.292      47858.292      1789.3833      1789.3833    
      8000  -13858.608     -13858.608     -14007.995     -14007.995      289.00049      289.00049      47971.786      47971.786     -1397.535      -1397.535     
Loop time of 106.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.482 hours/ns, 9.422 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    | 105.97     | 105.97     | 105.97     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03017    | 0.03017    | 0.03017    |   0.0 |  0.03
Output  | 7.2355e-05 | 7.2355e-05 | 7.2355e-05 |   0.0 |  0.00
Modify  | 0.12684    | 0.12684    | 0.12684    |   0.0 |  0.12
Other   |            | 0.01295    |            |       |  0.01

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

Total # of neighbors = 716544
Ave neighs/atom = 179.136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.062142063946, Press = -12.2121587068037
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13858.608     -13858.608     -14007.995     -14007.995      289.00049      289.00049      47971.786      47971.786     -1397.535      -1397.535     
      9000  -13855.399     -13855.399     -14005.368     -14005.368      290.12678      290.12678      47901.193      47901.193      1019.3223      1019.3223    
Loop time of 105.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.348 hours/ns, 9.465 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    | 105.48     | 105.48     | 105.48     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030166   | 0.030166   | 0.030166   |   0.0 |  0.03
Output  | 7.6945e-05 | 7.6945e-05 | 7.6945e-05 |   0.0 |  0.00
Modify  | 0.12709    | 0.12709    | 0.12709    |   0.0 |  0.12
Other   |            | 0.01294    |            |       |  0.01

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

Total # of neighbors = 715436
Ave neighs/atom = 178.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743709988285, Press = 11.5910425817617
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13855.399     -13855.399     -14005.368     -14005.368      290.12678      290.12678      47901.193      47901.193      1019.3223      1019.3223    
     10000  -13858.393     -13858.393     -14007.834     -14007.834      289.1043       289.1043       47922.37       47922.37       94.825085      94.825085    
Loop time of 106.154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.487 hours/ns, 9.420 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    | 105.98     | 105.98     | 105.98     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030109   | 0.030109   | 0.030109   |   0.0 |  0.03
Output  | 7.9048e-05 | 7.9048e-05 | 7.9048e-05 |   0.0 |  0.00
Modify  | 0.12709    | 0.12709    | 0.12709    |   0.0 |  0.12
Other   |            | 0.01292    |            |       |  0.01

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

Total # of neighbors = 716276
Ave neighs/atom = 179.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.911951095079, Press = -0.976366110528282
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13858.393     -13858.393     -14007.834     -14007.834      289.1043       289.1043       47922.37       47922.37       94.825085      94.825085    
     11000  -13858.43      -13858.43      -14007.172     -14007.172      287.75155      287.75155      47929.505      47929.505     -89.030368     -89.030368    
Loop time of 106.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.427 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    | 105.91     | 105.91     | 105.91     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029933   | 0.029933   | 0.029933   |   0.0 |  0.03
Output  | 7.5411e-05 | 7.5411e-05 | 7.5411e-05 |   0.0 |  0.00
Modify  | 0.12688    | 0.12688    | 0.12688    |   0.0 |  0.12
Other   |            | 0.01296    |            |       |  0.01

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

Total # of neighbors = 715802
Ave neighs/atom = 178.9505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.236953449518, Press = 3.67597980994668
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13858.43      -13858.43      -14007.172     -14007.172      287.75155      287.75155      47929.505      47929.505     -89.030368     -89.030368    
     12000  -13854.762     -13854.762     -14006.923     -14006.923      294.36674      294.36674      47909.752      47909.752      638.70903      638.70903    
Loop time of 105.848 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.402 hours/ns, 9.448 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    | 105.68     | 105.68     | 105.68     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.031399   | 0.031399   | 0.031399   |   0.0 |  0.03
Output  | 7.0563e-05 | 7.0563e-05 | 7.0563e-05 |   0.0 |  0.00
Modify  | 0.12715    | 0.12715    | 0.12715    |   0.0 |  0.12
Other   |            | 0.01298    |            |       |  0.01

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

Total # of neighbors = 715768
Ave neighs/atom = 178.942
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.033886922895, Press = -0.698170875915319
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13854.762     -13854.762     -14006.923     -14006.923      294.36674      294.36674      47909.752      47909.752      638.70903      638.70903    
     13000  -13859.421     -13859.421     -14009.658     -14009.658      290.64502      290.64502      47968.384      47968.384     -1361.9799     -1361.9799    
Loop time of 106.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.813 ns/day, 29.509 hours/ns, 9.413 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    | 106.06     | 106.06     | 106.06     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030068   | 0.030068   | 0.030068   |   0.0 |  0.03
Output  | 5.9141e-05 | 5.9141e-05 | 5.9141e-05 |   0.0 |  0.00
Modify  | 0.12683    | 0.12683    | 0.12683    |   0.0 |  0.12
Other   |            | 0.01293    |            |       |  0.01

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

Total # of neighbors = 715982
Ave neighs/atom = 178.9955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.981798418846, Press = 0.914980574237687
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13859.421     -13859.421     -14009.658     -14009.658      290.64502      290.64502      47968.384      47968.384     -1361.9799     -1361.9799    
     14000  -13856.536     -13856.536     -14006.476     -14006.476      290.06916      290.06916      47874.413      47874.413      1695.2615      1695.2615    
Loop time of 105.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.403 hours/ns, 9.447 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    | 105.68     | 105.68     | 105.68     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030062   | 0.030062   | 0.030062   |   0.0 |  0.03
Output  | 0.00014102 | 0.00014102 | 0.00014102 |   0.0 |  0.00
Modify  | 0.12653    | 0.12653    | 0.12653    |   0.0 |  0.12
Other   |            | 0.01291    |            |       |  0.01

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

Total # of neighbors = 715290
Ave neighs/atom = 178.8225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.934270790744, Press = 3.07254970129847
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13856.536     -13856.536     -14006.476     -14006.476      290.06916      290.06916      47874.413      47874.413      1695.2615      1695.2615    
     15000  -13861.282     -13861.282     -14010.737     -14010.737      289.13019      289.13019      47983.151      47983.151     -1953.9074     -1953.9074    
Loop time of 106.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.494 hours/ns, 9.418 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    | 106.01     | 106.01     | 106.01     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030024   | 0.030024   | 0.030024   |   0.0 |  0.03
Output  | 6.9039e-05 | 6.9039e-05 | 6.9039e-05 |   0.0 |  0.00
Modify  | 0.12671    | 0.12671    | 0.12671    |   0.0 |  0.12
Other   |            | 0.01297    |            |       |  0.01

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

Total # of neighbors = 716332
Ave neighs/atom = 179.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.769559537789, Press = -1.42538610866
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13861.282     -13861.282     -14010.737     -14010.737      289.13019      289.13019      47983.151      47983.151     -1953.9074     -1953.9074    
     16000  -13851.754     -13851.754     -14004.774     -14004.774      296.02736      296.02736      47877.837      47877.837      1871.2306      1871.2306    
Loop time of 105.968 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.436 hours/ns, 9.437 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    | 105.8      | 105.8      | 105.8      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029969   | 0.029969   | 0.029969   |   0.0 |  0.03
Output  | 6.5704e-05 | 6.5704e-05 | 6.5704e-05 |   0.0 |  0.00
Modify  | 0.12676    | 0.12676    | 0.12676    |   0.0 |  0.12
Other   |            | 0.01301    |            |       |  0.01

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

Total # of neighbors = 714956
Ave neighs/atom = 178.739
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819788006694, Press = 3.3606222259384
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13851.754     -13851.754     -14004.774     -14004.774      296.02736      296.02736      47877.837      47877.837      1871.2306      1871.2306    
     17000  -13858.174     -13858.174     -14010.139     -14010.139      293.98659      293.98659      47937.034      47937.034     -458.7612      -458.7612     
Loop time of 106.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.814 ns/day, 29.473 hours/ns, 9.425 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    | 105.93     | 105.93     | 105.93     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030038   | 0.030038   | 0.030038   |   0.0 |  0.03
Output  | 6.2297e-05 | 6.2297e-05 | 6.2297e-05 |   0.0 |  0.00
Modify  | 0.12678    | 0.12678    | 0.12678    |   0.0 |  0.12
Other   |            | 0.01296    |            |       |  0.01

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

Total # of neighbors = 716410
Ave neighs/atom = 179.1025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992527804312, Press = -0.520896074519404
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13858.174     -13858.174     -14010.139     -14010.139      293.98659      293.98659      47937.034      47937.034     -458.7612      -458.7612     
     18000  -13850.487     -13850.487     -14004.757     -14004.757      298.44528      298.44528      47931.721      47931.721      291.26749      291.26749    
Loop time of 105.677 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.818 ns/day, 29.355 hours/ns, 9.463 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    | 105.51     | 105.51     | 105.51     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029948   | 0.029948   | 0.029948   |   0.0 |  0.03
Output  | 6.5332e-05 | 6.5332e-05 | 6.5332e-05 |   0.0 |  0.00
Modify  | 0.12675    | 0.12675    | 0.12675    |   0.0 |  0.12
Other   |            | 0.01284    |            |       |  0.01

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

Total # of neighbors = 715292
Ave neighs/atom = 178.823
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.071894403536, Press = 1.66513704556208
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13850.487     -13850.487     -14004.757     -14004.757      298.44528      298.44528      47931.721      47931.721      291.26749      291.26749    
     19000  -13859.859     -13859.859     -14009.391     -14009.391      289.28089      289.28089      47944.861      47944.861     -631.26249     -631.26249    
Loop time of 105.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.431 hours/ns, 9.438 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    | 105.78     | 105.78     | 105.78     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030109   | 0.030109   | 0.030109   |   0.0 |  0.03
Output  | 6.9751e-05 | 6.9751e-05 | 6.9751e-05 |   0.0 |  0.00
Modify  | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.12
Other   |            | 0.01296    |            |       |  0.01

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

Total # of neighbors = 715754
Ave neighs/atom = 178.9385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154653859747, Press = 0.640112847354206
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13859.859     -13859.859     -14009.391     -14009.391      289.28089      289.28089      47944.861      47944.861     -631.26249     -631.26249    
     20000  -13853.448     -13853.448     -14006.252     -14006.252      295.61062      295.61062      47895.616      47895.616      1143.4228      1143.4228    
Loop time of 105.835 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.399 hours/ns, 9.449 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    | 105.66     | 105.66     | 105.66     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030207   | 0.030207   | 0.030207   |   0.0 |  0.03
Output  | 6.2097e-05 | 6.2097e-05 | 6.2097e-05 |   0.0 |  0.00
Modify  | 0.12696    | 0.12696    | 0.12696    |   0.0 |  0.12
Other   |            | 0.01296    |            |       |  0.01

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

Total # of neighbors = 715196
Ave neighs/atom = 178.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.186044754948, Press = 2.83251729977143
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13853.448     -13853.448     -14006.252     -14006.252      295.61062      295.61062      47895.616      47895.616      1143.4228      1143.4228    
     21000  -13852.213     -13852.213     -14005.346     -14005.346      296.24616      296.24616      47980.549      47980.549     -1220.396      -1220.396     
Loop time of 106.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.428 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    | 105.9      | 105.9      | 105.9      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030001   | 0.030001   | 0.030001   |   0.0 |  0.03
Output  | 7.7997e-05 | 7.7997e-05 | 7.7997e-05 |   0.0 |  0.00
Modify  | 0.12718    | 0.12718    | 0.12718    |   0.0 |  0.12
Other   |            | 0.01297    |            |       |  0.01

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

Total # of neighbors = 715980
Ave neighs/atom = 178.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.231479177297, Press = -1.54110678957758
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13852.213     -13852.213     -14005.346     -14005.346      296.24616      296.24616      47980.549      47980.549     -1220.396      -1220.396     
     22000  -13857.939     -13857.939     -14009.57      -14009.57       293.34188      293.34188      47877.796      47877.796      1194.5111      1194.5111    
Loop time of 106.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.460 hours/ns, 9.429 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    | 105.89     | 105.89     | 105.89     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030054   | 0.030054   | 0.030054   |   0.0 |  0.03
Output  | 7.7064e-05 | 7.7064e-05 | 7.7064e-05 |   0.0 |  0.00
Modify  | 0.1269     | 0.1269     | 0.1269     |   0.0 |  0.12
Other   |            | 0.01293    |            |       |  0.01

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

Total # of neighbors = 715192
Ave neighs/atom = 178.798
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.302580478625, Press = 3.0719412085705
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13857.939     -13857.939     -14009.57      -14009.57       293.34188      293.34188      47877.796      47877.796      1194.5111      1194.5111    
     23000  -13849.711     -13849.711     -14003.186     -14003.186      296.90854      296.90854      47971.419      47971.419     -706.8943      -706.8943     
Loop time of 106.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.463 hours/ns, 9.428 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    | 105.9      | 105.9      | 105.9      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029956   | 0.029956   | 0.029956   |   0.0 |  0.03
Output  | 7.2516e-05 | 7.2516e-05 | 7.2516e-05 |   0.0 |  0.00
Modify  | 0.12687    | 0.12687    | 0.12687    |   0.0 |  0.12
Other   |            | 0.01297    |            |       |  0.01

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

Total # of neighbors = 716164
Ave neighs/atom = 179.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.389257597212, Press = -1.4414891911859
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13849.711     -13849.711     -14003.186     -14003.186      296.90854      296.90854      47971.419      47971.419     -706.8943      -706.8943     
     24000  -13857.41      -13857.41      -14007.548     -14007.548      290.45261      290.45261      47891.983      47891.983      1006.3734      1006.3734    
Loop time of 106.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.445 hours/ns, 9.434 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    | 105.83     | 105.83     | 105.83     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029739   | 0.029739   | 0.029739   |   0.0 |  0.03
Output  | 7.0182e-05 | 7.0182e-05 | 7.0182e-05 |   0.0 |  0.00
Modify  | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.12
Other   |            | 0.01289    |            |       |  0.01

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

Total # of neighbors = 715504
Ave neighs/atom = 178.876
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.418880062495, Press = 1.42950849583434
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13857.41      -13857.41      -14007.548     -14007.548      290.45261      290.45261      47891.983      47891.983      1006.3734      1006.3734    
     25000  -13863.696     -13863.696     -14012.893     -14012.893      288.63145      288.63145      47915.643      47915.643     -282.05361     -282.05361    
Loop time of 106.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.450 hours/ns, 9.432 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    | 105.85     | 105.85     | 105.85     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029785   | 0.029785   | 0.029785   |   0.0 |  0.03
Output  | 6.1856e-05 | 6.1856e-05 | 6.1856e-05 |   0.0 |  0.00
Modify  | 0.12649    | 0.12649    | 0.12649    |   0.0 |  0.12
Other   |            | 0.01293    |            |       |  0.01

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

Total # of neighbors = 716346
Ave neighs/atom = 179.0865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.366880608123, Press = 0.031988565051697
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13863.696     -13863.696     -14012.893     -14012.893      288.63145      288.63145      47915.643      47915.643     -282.05361     -282.05361    
     26000  -13855.726     -13855.726     -14006.698     -14006.698      292.06569      292.06569      47908.174      47908.174      646.3718       646.3718     
Loop time of 106.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.449 hours/ns, 9.433 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    | 105.85     | 105.85     | 105.85     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029659   | 0.029659   | 0.029659   |   0.0 |  0.03
Output  | 7.3518e-05 | 7.3518e-05 | 7.3518e-05 |   0.0 |  0.00
Modify  | 0.12612    | 0.12612    | 0.12612    |   0.0 |  0.12
Other   |            | 0.01277    |            |       |  0.01

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

Total # of neighbors = 715568
Ave neighs/atom = 178.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.303103545869, Press = 1.03393493435893
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13855.726     -13855.726     -14006.698     -14006.698      292.06569      292.06569      47908.174      47908.174      646.3718       646.3718     
     27000  -13861.089     -13861.089     -14010.872     -14010.872      289.76654      289.76654      47928.672      47928.672     -447.82275     -447.82275    
Loop time of 105.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.433 hours/ns, 9.438 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    | 105.79     | 105.79     | 105.79     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029783   | 0.029783   | 0.029783   |   0.0 |  0.03
Output  | 7.3488e-05 | 7.3488e-05 | 7.3488e-05 |   0.0 |  0.00
Modify  | 0.12621    | 0.12621    | 0.12621    |   0.0 |  0.12
Other   |            | 0.0128     |            |       |  0.01

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

Total # of neighbors = 716222
Ave neighs/atom = 179.0555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.2296875201, Press = -0.488097760958557
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13861.089     -13861.089     -14010.872     -14010.872      289.76654      289.76654      47928.672      47928.672     -447.82275     -447.82275    
     28000  -13858.358     -13858.358     -14009.667     -14009.667      292.7181       292.7181       47856.739      47856.739      1728.8283      1728.8283    
Loop time of 106.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.815 ns/day, 29.463 hours/ns, 9.428 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    | 105.9      | 105.9      | 105.9      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029805   | 0.029805   | 0.029805   |   0.0 |  0.03
Output  | 7.0342e-05 | 7.0342e-05 | 7.0342e-05 |   0.0 |  0.00
Modify  | 0.12614    | 0.12614    | 0.12614    |   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:           8195 ave        8195 max        8195 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:       715540 ave      715540 max      715540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715540
Ave neighs/atom = 178.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.256190994495, Press = 2.21612279869813
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13858.358     -13858.358     -14009.667     -14009.667      292.7181       292.7181       47856.739      47856.739      1728.8283      1728.8283    
     29000  -13857.566     -13857.566     -14006.328     -14006.328      287.78935      287.78935      47978.686      47978.686     -1402.2326     -1402.2326    
Loop time of 106.233 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.813 ns/day, 29.509 hours/ns, 9.413 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    | 106.06     | 106.06     | 106.06     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029675   | 0.029675   | 0.029675   |   0.0 |  0.03
Output  | 6.3038e-05 | 6.3038e-05 | 6.3038e-05 |   0.0 |  0.00
Modify  | 0.12661    | 0.12661    | 0.12661    |   0.0 |  0.12
Other   |            | 0.01285    |            |       |  0.01

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

Total # of neighbors = 716428
Ave neighs/atom = 179.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.283669695676, Press = -1.2155974290001
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13857.566     -13857.566     -14006.328     -14006.328      287.78935      287.78935      47978.686      47978.686     -1402.2326     -1402.2326    
     30000  -13857.032     -13857.032     -14008.161     -14008.161      292.36883      292.36883      47895.373      47895.373      856.61842      856.61842    
Loop time of 105.733 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.370 hours/ns, 9.458 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    | 105.56     | 105.56     | 105.56     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029623   | 0.029623   | 0.029623   |   0.0 |  0.03
Output  | 7.3488e-05 | 7.3488e-05 | 7.3488e-05 |   0.0 |  0.00
Modify  | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.12
Other   |            | 0.01286    |            |       |  0.01

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

Total # of neighbors = 715608
Ave neighs/atom = 178.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.283078754976, Press = 1.59719210736563
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13857.032     -13857.032     -14008.161     -14008.161      292.36883      292.36883      47895.373      47895.373      856.61842      856.61842    
     31000  -13854.896     -13854.896     -14008.004     -14008.004      296.19841      296.19841      47948.854      47948.854     -502.94        -502.94       
Loop time of 105.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.817 ns/day, 29.381 hours/ns, 9.454 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    | 105.6      | 105.6      | 105.6      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029705   | 0.029705   | 0.029705   |   0.0 |  0.03
Output  | 7.46e-05   | 7.46e-05   | 7.46e-05   |   0.0 |  0.00
Modify  | 0.1264     | 0.1264     | 0.1264     |   0.0 |  0.12
Other   |            | 0.01286    |            |       |  0.01

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

Total # of neighbors = 716028
Ave neighs/atom = 179.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.280787825583, Press = -0.235487825988372
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13854.896     -13854.896     -14008.004     -14008.004      296.19841      296.19841      47948.854      47948.854     -502.94        -502.94       
     32000  -13858.119     -13858.119     -14007.615     -14007.615      289.21045      289.21045      47900.455      47900.455      749.42464      749.42464    
Loop time of 105.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.410 hours/ns, 9.445 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    | 105.71     | 105.71     | 105.71     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029784   | 0.029784   | 0.029784   |   0.0 |  0.03
Output  | 6.8218e-05 | 6.8218e-05 | 6.8218e-05 |   0.0 |  0.00
Modify  | 0.12638    | 0.12638    | 0.12638    |   0.0 |  0.12
Other   |            | 0.01274    |            |       |  0.01

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

Total # of neighbors = 715454
Ave neighs/atom = 178.8635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.287234691934, Press = 0.515375219584782
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13858.119     -13858.119     -14007.615     -14007.615      289.21045      289.21045      47900.455      47900.455      749.42464      749.42464    
     33000  -13852.449     -13852.449     -14007.474     -14007.474      299.90764      299.90764      47985.111      47985.111     -1613.4922     -1613.4922    
Loop time of 105.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.816 ns/day, 29.399 hours/ns, 9.449 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    | 105.67     | 105.67     | 105.67     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029733   | 0.029733   | 0.029733   |   0.0 |  0.03
Output  | 6.6646e-05 | 6.6646e-05 | 6.6646e-05 |   0.0 |  0.00
Modify  | 0.12608    | 0.12608    | 0.12608    |   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:           8195 ave        8195 max        8195 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:       715942 ave      715942 max      715942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 715942
Ave neighs/atom = 178.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
47924.8572360183

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0