# 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.6200000196695328*${_u_distance}
variable latticeconst_converted equal 3.6200000196695328*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.62000001966953
Lattice spacing in x,y,z = 3.62 3.62 3.62
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  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.2 36.2 36.2)
  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_JelinekGrohHorstemeyer_2012_AlSiMgCuFe__MO_262519520678_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 47437.9287732722    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9287732722/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9287732722/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47437.9287732722/(1*1*${_u_distance})
variable      V0_metal equal 47437.9287732722/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47437.9287732722*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_262519520678_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  -14029.144     -14029.144     -14160         -14160          253.15         253.15         47437.929      47437.929      2946.3562      2946.3562    
      1000  -13887.551     -13887.551     -14016.508     -14016.508      249.47652      249.47652      47990.883      47990.883      1306.7953      1306.7953    
Loop time of 99.9682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.864 ns/day, 27.769 hours/ns, 10.003 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    | 99.815     | 99.815     | 99.815     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022059   | 0.022059   | 0.022059   |   0.0 |  0.02
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.12028    | 0.12028    | 0.12028    |   0.0 |  0.12
Other   |            | 0.01078    |            |       |  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.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   
      1000  -13887.551     -13887.551     -14016.508     -14016.508      249.47652      249.47652      47990.883      47990.883      1306.7953      1306.7953    
      2000  -13898.297     -13898.297     -14027.124     -14027.124      249.2244       249.2244       47984.591      47984.591      446.76762      446.76762    
Loop time of 103.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.718 hours/ns, 9.673 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    | 103.23     | 103.23     | 103.23     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021883   | 0.021883   | 0.021883   |   0.0 |  0.02
Output  | 6.363e-05  | 6.363e-05  | 6.363e-05  |   0.0 |  0.00
Modify  | 0.11999    | 0.11999    | 0.11999    |   0.0 |  0.12
Other   |            | 0.01054    |            |       |  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:       530614 ave      530614 max      530614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530614
Ave neighs/atom = 132.6535
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.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   
      2000  -13898.297     -13898.297     -14027.124     -14027.124      249.2244       249.2244       47984.591      47984.591      446.76762      446.76762    
      3000  -13893.836     -13893.836     -14026.604     -14026.604      256.84808      256.84808      48026.43       48026.43      -673.15125     -673.15125    
Loop time of 103.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.824 hours/ns, 9.637 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    | 103.61     | 103.61     | 103.61     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021722   | 0.021722   | 0.021722   |   0.0 |  0.02
Output  | 6.7737e-05 | 6.7737e-05 | 6.7737e-05 |   0.0 |  0.00
Modify  | 0.11998    | 0.11998    | 0.11998    |   0.0 |  0.12
Other   |            | 0.01052    |            |       |  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:       531952 ave      531952 max      531952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531952
Ave neighs/atom = 132.988
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.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   
      3000  -13893.836     -13893.836     -14026.604     -14026.604      256.84808      256.84808      48026.43       48026.43      -673.15125     -673.15125    
      4000  -13897.236     -13897.236     -14027.658     -14027.658      252.31051      252.31051      47991.845      47991.845      253.79557      253.79557    
Loop time of 103.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.713 hours/ns, 9.674 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    | 103.22     | 103.22     | 103.22     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021722   | 0.021722   | 0.021722   |   0.0 |  0.02
Output  | 6.3029e-05 | 6.3029e-05 | 6.3029e-05 |   0.0 |  0.00
Modify  | 0.11985    | 0.11985    | 0.11985    |   0.0 |  0.12
Other   |            | 0.01055    |            |       |  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:       531318 ave      531318 max      531318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531318
Ave neighs/atom = 132.8295
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.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   
      4000  -13897.236     -13897.236     -14027.658     -14027.658      252.31051      252.31051      47991.845      47991.845      253.79557      253.79557    
      5000  -13892.413     -13892.413     -14027.222     -14027.222      260.79643      260.79643      48032.08       48032.08      -724.80026     -724.80026    
Loop time of 103.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.729 hours/ns, 9.669 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    | 103.27     | 103.27     | 103.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021651   | 0.021651   | 0.021651   |   0.0 |  0.02
Output  | 4.818e-05  | 4.818e-05  | 4.818e-05  |   0.0 |  0.00
Modify  | 0.12009    | 0.12009    | 0.12009    |   0.0 |  0.12
Other   |            | 0.01054    |            |       |  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:       531970 ave      531970 max      531970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531970
Ave neighs/atom = 132.9925
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 = 255.778307405937, Press = -397.350986780322
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.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   
      5000  -13892.413     -13892.413     -14027.222     -14027.222      260.79643      260.79643      48032.08       48032.08      -724.80026     -724.80026    
      6000  -13898.589     -13898.589     -14029.255     -14029.255      252.78065      252.78065      48051.494      48051.494     -1526.3651     -1526.3651    
Loop time of 103.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.713 hours/ns, 9.674 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021939   | 0.021939   | 0.021939   |   0.0 |  0.02
Output  | 4.9704e-05 | 4.9704e-05 | 4.9704e-05 |   0.0 |  0.00
Modify  | 0.12364    | 0.12364    | 0.12364    |   0.0 |  0.12
Other   |            | 0.01033    |            |       |  0.01

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

Total # of neighbors = 531670
Ave neighs/atom = 132.9175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.159036625379, Press = -21.605558553245
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.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   
      6000  -13898.589     -13898.589     -14029.255     -14029.255      252.78065      252.78065      48051.494      48051.494     -1526.3651     -1526.3651    
      7000  -13892.729     -13892.729     -14023.472     -14023.472      252.93247      252.93247      48053.942      48053.942     -1108.2772     -1108.2772    
Loop time of 103.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.746 hours/ns, 9.663 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    | 103.33     | 103.33     | 103.33     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021767   | 0.021767   | 0.021767   |   0.0 |  0.02
Output  | 4.6337e-05 | 4.6337e-05 | 4.6337e-05 |   0.0 |  0.00
Modify  | 0.12359    | 0.12359    | 0.12359    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  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:       531842 ave      531842 max      531842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531842
Ave neighs/atom = 132.9605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.198650212247, Press = 7.97144232095633
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.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   
      7000  -13892.729     -13892.729     -14023.472     -14023.472      252.93247      252.93247      48053.942      48053.942     -1108.2772     -1108.2772    
      8000  -13895.429     -13895.429     -14027.726     -14027.726      255.93768      255.93768      48009.735      48009.735     -234.60298     -234.60298    
Loop time of 103.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.751 hours/ns, 9.662 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    | 103.35     | 103.35     | 103.35     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021629   | 0.021629   | 0.021629   |   0.0 |  0.02
Output  | 4.4413e-05 | 4.4413e-05 | 4.4413e-05 |   0.0 |  0.00
Modify  | 0.12362    | 0.12362    | 0.12362    |   0.0 |  0.12
Other   |            | 0.01035    |            |       |  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:       531166 ave      531166 max      531166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531166
Ave neighs/atom = 132.7915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.175339751772, Press = 15.0313615731898
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.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   
      8000  -13895.429     -13895.429     -14027.726     -14027.726      255.93768      255.93768      48009.735      48009.735     -234.60298     -234.60298    
      9000  -13892.321     -13892.321     -14025.74      -14025.74       258.10971      258.10971      47989.811      47989.811      537.77262      537.77262    
Loop time of 103.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.790 hours/ns, 9.648 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    | 103.49     | 103.49     | 103.49     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021721   | 0.021721   | 0.021721   |   0.0 |  0.02
Output  | 5.0825e-05 | 5.0825e-05 | 5.0825e-05 |   0.0 |  0.00
Modify  | 0.12361    | 0.12361    | 0.12361    |   0.0 |  0.12
Other   |            | 0.01033    |            |       |  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:       531830 ave      531830 max      531830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531830
Ave neighs/atom = 132.9575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.081508539052, Press = 6.42143355002096
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.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   
      9000  -13892.321     -13892.321     -14025.74      -14025.74       258.10971      258.10971      47989.811      47989.811      537.77262      537.77262    
     10000  -13896.192     -13896.192     -14028.287     -14028.287      255.5477       255.5477       47970.226      47970.226      800.14579      800.14579    
Loop time of 103.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.784 hours/ns, 9.650 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    | 103.47     | 103.47     | 103.47     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021825   | 0.021825   | 0.021825   |   0.0 |  0.02
Output  | 4.9052e-05 | 4.9052e-05 | 4.9052e-05 |   0.0 |  0.00
Modify  | 0.12397    | 0.12397    | 0.12397    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  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:       531652 ave      531652 max      531652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531652
Ave neighs/atom = 132.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.156420868193, Press = 1.05020938502931
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.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   
     10000  -13896.192     -13896.192     -14028.287     -14028.287      255.5477       255.5477       47970.226      47970.226      800.14579      800.14579    
     11000  -13892.993     -13892.993     -14025.164     -14025.164      255.69433      255.69433      47993.319      47993.319      486.99166      486.99166    
Loop time of 103.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.789 hours/ns, 9.649 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    | 103.49     | 103.49     | 103.49     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021675   | 0.021675   | 0.021675   |   0.0 |  0.02
Output  | 4.7269e-05 | 4.7269e-05 | 4.7269e-05 |   0.0 |  0.00
Modify  | 0.12374    | 0.12374    | 0.12374    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  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:       531976 ave      531976 max      531976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531976
Ave neighs/atom = 132.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.333942017434, Press = -2.91858130299963
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.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   
     11000  -13892.993     -13892.993     -14025.164     -14025.164      255.69433      255.69433      47993.319      47993.319      486.99166      486.99166    
     12000  -13900.732     -13900.732     -14030.358     -14030.358      250.77191      250.77191      47983.444      47983.444      204.73249      204.73249    
Loop time of 103.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.811 hours/ns, 9.641 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    | 103.56     | 103.56     | 103.56     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021699   | 0.021699   | 0.021699   |   0.0 |  0.02
Output  | 4.8622e-05 | 4.8622e-05 | 4.8622e-05 |   0.0 |  0.00
Modify  | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.12
Other   |            | 0.01036    |            |       |  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:       531724 ave      531724 max      531724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531724
Ave neighs/atom = 132.931
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.167940314043, Press = -3.4933329405438
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.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   
     12000  -13900.732     -13900.732     -14030.358     -14030.358      250.77191      250.77191      47983.444      47983.444      204.73249      204.73249    
     13000  -13893.422     -13893.422     -14023.071     -14023.071      250.81448      250.81448      47993.729      47993.729      739.3139       739.3139     
Loop time of 103.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.803 hours/ns, 9.644 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    | 103.53     | 103.53     | 103.53     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021759   | 0.021759   | 0.021759   |   0.0 |  0.02
Output  | 4.9654e-05 | 4.9654e-05 | 4.9654e-05 |   0.0 |  0.00
Modify  | 0.12375    | 0.12375    | 0.12375    |   0.0 |  0.12
Other   |            | 0.01034    |            |       |  0.01

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

Total # of neighbors = 532250
Ave neighs/atom = 133.0625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.091511198219, Press = -4.4913736599745
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.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   
     13000  -13893.422     -13893.422     -14023.071     -14023.071      250.81448      250.81448      47993.729      47993.729      739.3139       739.3139     
     14000  -13896.483     -13896.483     -14028.898     -14028.898      256.16542      256.16542      47996.685      47996.685      78.788659      78.788659    
Loop time of 103.578 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.772 hours/ns, 9.655 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    | 103.42     | 103.42     | 103.42     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021852   | 0.021852   | 0.021852   |   0.0 |  0.02
Output  | 0.00010178 | 0.00010178 | 0.00010178 |   0.0 |  0.00
Modify  | 0.12359    | 0.12359    | 0.12359    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  0.01

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

Total # of neighbors = 531624
Ave neighs/atom = 132.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.230887429706, Press = -7.73952100558755
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.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   
     14000  -13896.483     -13896.483     -14028.898     -14028.898      256.16542      256.16542      47996.685      47996.685      78.788659      78.788659    
     15000  -13897.116     -13897.116     -14028.284     -14028.284      253.75224      253.75224      48026.349      48026.349     -768.37605     -768.37605    
Loop time of 103.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.787 hours/ns, 9.649 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    | 103.48     | 103.48     | 103.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021771   | 0.021771   | 0.021771   |   0.0 |  0.02
Output  | 4.9092e-05 | 4.9092e-05 | 4.9092e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.12
Other   |            | 0.01035    |            |       |  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:       532040 ave      532040 max      532040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532040
Ave neighs/atom = 133.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.309240016259, Press = -6.08885839559871
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.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   
     15000  -13897.116     -13897.116     -14028.284     -14028.284      253.75224      253.75224      48026.349      48026.349     -768.37605     -768.37605    
     16000  -13895.26      -13895.26      -14026.064     -14026.064      253.04947      253.04947      48023.926      48023.926     -436.00618     -436.00618    
Loop time of 103.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.833 ns/day, 28.809 hours/ns, 9.642 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    | 103.56     | 103.56     | 103.56     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.02
Output  | 7.4551e-05 | 7.4551e-05 | 7.4551e-05 |   0.0 |  0.00
Modify  | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.12
Other   |            | 0.01039    |            |       |  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:       531820 ave      531820 max      531820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531820
Ave neighs/atom = 132.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.270564914489, Press = -2.45090684441701
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.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   
     16000  -13895.26      -13895.26      -14026.064     -14026.064      253.04947      253.04947      48023.926      48023.926     -436.00618     -436.00618    
     17000  -13891.446     -13891.446     -14021.565     -14021.565      251.72359      251.72359      48033.272      48033.272     -292.4117      -292.4117     
Loop time of 103.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.831 ns/day, 28.867 hours/ns, 9.623 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    | 103.76     | 103.76     | 103.76     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021738   | 0.021738   | 0.021738   |   0.0 |  0.02
Output  | 5.4944e-05 | 5.4944e-05 | 5.4944e-05 |   0.0 |  0.00
Modify  | 0.12351    | 0.12351    | 0.12351    |   0.0 |  0.12
Other   |            | 0.01039    |            |       |  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:       531838 ave      531838 max      531838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531838
Ave neighs/atom = 132.9595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.312360726191, Press = -1.16971533328494
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.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   
     17000  -13891.446     -13891.446     -14021.565     -14021.565      251.72359      251.72359      48033.272      48033.272     -292.4117      -292.4117     
     18000  -13895.681     -13895.681     -14025.137     -14025.137      250.44098      250.44098      48037.23       48037.23      -711.73193     -711.73193    
Loop time of 103.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.774 hours/ns, 9.654 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    | 103.43     | 103.43     | 103.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021745   | 0.021745   | 0.021745   |   0.0 |  0.02
Output  | 5.3461e-05 | 5.3461e-05 | 5.3461e-05 |   0.0 |  0.00
Modify  | 0.12342    | 0.12342    | 0.12342    |   0.0 |  0.12
Other   |            | 0.01036    |            |       |  0.01

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

Total # of neighbors = 531112
Ave neighs/atom = 132.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.456749906484, Press = -0.57773618018397
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.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   
     18000  -13895.681     -13895.681     -14025.137     -14025.137      250.44098      250.44098      48037.23       48037.23      -711.73193     -711.73193    
     19000  -13895.27      -13895.27      -14027.601     -14027.601      256.00313      256.00313      48055.815      48055.815     -1397.1898     -1397.1898    
Loop time of 103.454 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.737 hours/ns, 9.666 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    | 103.3      | 103.3      | 103.3      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021783   | 0.021783   | 0.021783   |   0.0 |  0.02
Output  | 5.0174e-05 | 5.0174e-05 | 5.0174e-05 |   0.0 |  0.00
Modify  | 0.12381    | 0.12381    | 0.12381    |   0.0 |  0.12
Other   |            | 0.01035    |            |       |  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:       531666 ave      531666 max      531666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531666
Ave neighs/atom = 132.9165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.499381887703, Press = 2.84452536205834
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.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   
     19000  -13895.27      -13895.27      -14027.601     -14027.601      256.00313      256.00313      48055.815      48055.815     -1397.1898     -1397.1898    
     20000  -13897.27      -13897.27      -14027.151     -14027.151      251.26384      251.26384      48001.897      48001.897      4.1137829      4.1137829    
Loop time of 103.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.731 hours/ns, 9.668 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    | 103.27     | 103.27     | 103.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021702   | 0.021702   | 0.021702   |   0.0 |  0.02
Output  | 5.4513e-05 | 5.4513e-05 | 5.4513e-05 |   0.0 |  0.00
Modify  | 0.12355    | 0.12355    | 0.12355    |   0.0 |  0.12
Other   |            | 0.01036    |            |       |  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:       531856 ave      531856 max      531856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531856
Ave neighs/atom = 132.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.559616016181, Press = 2.60782500697858
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.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   
     20000  -13897.27      -13897.27      -14027.151     -14027.151      251.26384      251.26384      48001.897      48001.897      4.1137829      4.1137829    
     21000  -13891.612     -13891.612     -14022.036     -14022.036      252.31542      252.31542      47980.858      47980.858      1109.1138      1109.1138    
Loop time of 103.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.702 hours/ns, 9.678 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    | 103.17     | 103.17     | 103.17     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02172    | 0.02172    | 0.02172    |   0.0 |  0.02
Output  | 5.4403e-05 | 5.4403e-05 | 5.4403e-05 |   0.0 |  0.00
Modify  | 0.12337    | 0.12337    | 0.12337    |   0.0 |  0.12
Other   |            | 0.01039    |            |       |  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:       531808 ave      531808 max      531808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531808
Ave neighs/atom = 132.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.559695886005, Press = 0.669492012531087
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.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   
     21000  -13891.612     -13891.612     -14022.036     -14022.036      252.31542      252.31542      47980.858      47980.858      1109.1138      1109.1138    
     22000  -13896.645     -13896.645     -14025.689     -14025.689      249.64471      249.64471      47970.974      47970.974      1017.0378      1017.0378    
Loop time of 103.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.726 hours/ns, 9.670 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    | 103.26     | 103.26     | 103.26     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021759   | 0.021759   | 0.021759   |   0.0 |  0.02
Output  | 5.3059e-05 | 5.3059e-05 | 5.3059e-05 |   0.0 |  0.00
Modify  | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.12
Other   |            | 0.01036    |            |       |  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:       531544 ave      531544 max      531544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531544
Ave neighs/atom = 132.886
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.522918341502, Press = -0.249828099263067
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.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   
     22000  -13896.645     -13896.645     -14025.689     -14025.689      249.64471      249.64471      47970.974      47970.974      1017.0378      1017.0378    
     23000  -13893.003     -13893.003     -14025.12      -14025.12       255.58827      255.58827      47995.112      47995.112      511.46315      511.46315    
Loop time of 103.45 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.736 hours/ns, 9.666 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    | 103.29     | 103.29     | 103.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021624   | 0.021624   | 0.021624   |   0.0 |  0.02
Output  | 5.5595e-05 | 5.5595e-05 | 5.5595e-05 |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.12
Other   |            | 0.01032    |            |       |  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:       531956 ave      531956 max      531956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531956
Ave neighs/atom = 132.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.509143424225, Press = -1.05151357646177
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.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   
     23000  -13893.003     -13893.003     -14025.12      -14025.12       255.58827      255.58827      47995.112      47995.112      511.46315      511.46315    
     24000  -13896.579     -13896.579     -14025.865     -14025.865      250.11314      250.11314      47972.422      47972.422      1055.2983      1055.2983    
Loop time of 103.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.713 hours/ns, 9.674 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021648   | 0.021648   | 0.021648   |   0.0 |  0.02
Output  | 5.4472e-05 | 5.4472e-05 | 5.4472e-05 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  0.01

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

Total # of neighbors = 531812
Ave neighs/atom = 132.953
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.550604768487, Press = -2.49352568501717
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.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   
     24000  -13896.579     -13896.579     -14025.865     -14025.865      250.11314      250.11314      47972.422      47972.422      1055.2983      1055.2983    
     25000  -13895.082     -13895.082     -14025.022     -14025.022      251.37717      251.37717      48025.783      48025.783     -426.41876     -426.41876    
Loop time of 103.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.834 ns/day, 28.782 hours/ns, 9.651 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    | 103.46     | 103.46     | 103.46     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021603   | 0.021603   | 0.021603   |   0.0 |  0.02
Output  | 5.2328e-05 | 5.2328e-05 | 5.2328e-05 |   0.0 |  0.00
Modify  | 0.12339    | 0.12339    | 0.12339    |   0.0 |  0.12
Other   |            | 0.01034    |            |       |  0.01

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

Total # of neighbors = 532196
Ave neighs/atom = 133.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.497924052764, Press = -4.26938960855042
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.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   
     25000  -13895.082     -13895.082     -14025.022     -14025.022      251.37717      251.37717      48025.783      48025.783     -426.41876     -426.41876    
     26000  -13900.379     -13900.379     -14028.252     -14028.252      247.37872      247.37872      48034.03       48034.03      -1064.4871     -1064.4871    
Loop time of 103.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.711 hours/ns, 9.675 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021747   | 0.021747   | 0.021747   |   0.0 |  0.02
Output  | 4.8872e-05 | 4.8872e-05 | 4.8872e-05 |   0.0 |  0.00
Modify  | 0.12355    | 0.12355    | 0.12355    |   0.0 |  0.12
Other   |            | 0.01037    |            |       |  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:       531740 ave      531740 max      531740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531740
Ave neighs/atom = 132.935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.457893839, Press = -2.01061485219757
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.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   
     26000  -13900.379     -13900.379     -14028.252     -14028.252      247.37872      247.37872      48034.03       48034.03      -1064.4871     -1064.4871    
     27000  -13895.213     -13895.213     -14025.614     -14025.614      252.27016      252.27016      48046.475      48046.475     -1058.1428     -1058.1428    
Loop time of 103.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.697 hours/ns, 9.680 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    | 103.15     | 103.15     | 103.15     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.02
Output  | 5.5304e-05 | 5.5304e-05 | 5.5304e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01034    |            |       |  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:       531926 ave      531926 max      531926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531926
Ave neighs/atom = 132.9815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.384810869347, Press = -0.641718582289528
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.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   
     27000  -13895.213     -13895.213     -14025.614     -14025.614      252.27016      252.27016      48046.475      48046.475     -1058.1428     -1058.1428    
     28000  -13894.486     -13894.486     -14026.266     -14026.266      254.93737      254.93737      48028.674      48028.674     -682.35408     -682.35408    
Loop time of 103.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.683 hours/ns, 9.685 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    | 103.1      | 103.1      | 103.1      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02165    | 0.02165    | 0.02165    |   0.0 |  0.02
Output  | 6.2297e-05 | 6.2297e-05 | 6.2297e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.12
Other   |            | 0.01038    |            |       |  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:       531394 ave      531394 max      531394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531394
Ave neighs/atom = 132.8485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.427967969456, Press = 0.0188711803659941
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.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   
     28000  -13894.486     -13894.486     -14026.266     -14026.266      254.93737      254.93737      48028.674      48028.674     -682.35408     -682.35408    
     29000  -13894.663     -13894.663     -14027.255     -14027.255      256.5083       256.5083       48018.049      48018.049     -381.90571     -381.90571    
Loop time of 103.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.695 hours/ns, 9.680 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    | 103.15     | 103.15     | 103.15     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.02
Output  | 5.822e-05  | 5.822e-05  | 5.822e-05  |   0.0 |  0.00
Modify  | 0.12294    | 0.12294    | 0.12294    |   0.0 |  0.12
Other   |            | 0.01044    |            |       |  0.01

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

Total # of neighbors = 531398
Ave neighs/atom = 132.8495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.41686176976, Press = 0.40391641381409
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.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   
     29000  -13894.663     -13894.663     -14027.255     -14027.255      256.5083       256.5083       48018.049      48018.049     -381.90571     -381.90571    
     30000  -13895.601     -13895.601     -14026.909     -14026.909      254.02508      254.02508      47992.658      47992.658      322.98138      322.98138    
Loop time of 103.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.838 ns/day, 28.655 hours/ns, 9.694 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    | 103        | 103        | 103        |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021628   | 0.021628   | 0.021628   |   0.0 |  0.02
Output  | 6.2598e-05 | 6.2598e-05 | 6.2598e-05 |   0.0 |  0.00
Modify  | 0.12293    | 0.12293    | 0.12293    |   0.0 |  0.12
Other   |            | 0.01039    |            |       |  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:       531710 ave      531710 max      531710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531710
Ave neighs/atom = 132.9275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.472817122433, Press = 0.586394967003386
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.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   
     30000  -13895.601     -13895.601     -14026.909     -14026.909      254.02508      254.02508      47992.658      47992.658      322.98138      322.98138    
     31000  -13893.897     -13893.897     -14025.871     -14025.871      255.3144       255.3144       47986.938      47986.938      577.70216      577.70216    
Loop time of 103.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.712 hours/ns, 9.675 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021525   | 0.021525   | 0.021525   |   0.0 |  0.02
Output  | 6.2788e-05 | 6.2788e-05 | 6.2788e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.12
Other   |            | 0.01046    |            |       |  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:       531962 ave      531962 max      531962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531962
Ave neighs/atom = 132.9905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.434773098231, Press = 0.0190683976013283
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.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   
     31000  -13893.897     -13893.897     -14025.871     -14025.871      255.3144       255.3144       47986.938      47986.938      577.70216      577.70216    
     32000  -13898.401     -13898.401     -14030.616     -14030.616      255.7786       255.7786       47980.56       47980.56       294.22399      294.22399    
Loop time of 103.465 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.835 ns/day, 28.740 hours/ns, 9.665 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    | 103.31     | 103.31     | 103.31     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021514   | 0.021514   | 0.021514   |   0.0 |  0.02
Output  | 5.7318e-05 | 5.7318e-05 | 5.7318e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.12
Other   |            | 0.01044    |            |       |  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:       531828 ave      531828 max      531828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531828
Ave neighs/atom = 132.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.381321462447, Press = -0.45252860832873
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.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   
     32000  -13898.401     -13898.401     -14030.616     -14030.616      255.7786       255.7786       47980.56       47980.56       294.22399      294.22399    
     33000  -13895.401     -13895.401     -14027.112     -14027.112      254.80284      254.80284      47985.001      47985.001      578.60681      578.60681    
Loop time of 103.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.710 hours/ns, 9.675 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    | 103.2      | 103.2      | 103.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02157    | 0.02157    | 0.02157    |   0.0 |  0.02
Output  | 5.339e-05  | 5.339e-05  | 5.339e-05  |   0.0 |  0.00
Modify  | 0.12286    | 0.12286    | 0.12286    |   0.0 |  0.12
Other   |            | 0.01044    |            |       |  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:       532170 ave      532170 max      532170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532170
Ave neighs/atom = 133.0425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.310468054217, Press = -1.19756551597789
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.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   
     33000  -13895.401     -13895.401     -14027.112     -14027.112      254.80284      254.80284      47985.001      47985.001      578.60681      578.60681    
     34000  -13896.712     -13896.712     -14026.749     -14026.749      251.56598      251.56598      48003.157      48003.157     -1.4300514     -1.4300514    
Loop time of 103.289 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.692 hours/ns, 9.682 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    | 103.13     | 103.13     | 103.13     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021646   | 0.021646   | 0.021646   |   0.0 |  0.02
Output  | 6.4492e-05 | 6.4492e-05 | 6.4492e-05 |   0.0 |  0.00
Modify  | 0.12343    | 0.12343    | 0.12343    |   0.0 |  0.12
Other   |            | 0.01041    |            |       |  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:       531964 ave      531964 max      531964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531964
Ave neighs/atom = 132.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.316125196057, Press = -2.19277549875767
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.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   
     34000  -13896.712     -13896.712     -14026.749     -14026.749      251.56598      251.56598      48003.157      48003.157     -1.4300514     -1.4300514    
     35000  -13891.398     -13891.398     -14022.628     -14022.628      253.87286      253.87286      48039.196      48039.196     -588.43227     -588.43227    
Loop time of 103.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.837 ns/day, 28.671 hours/ns, 9.689 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    | 103.06     | 103.06     | 103.06     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02173    | 0.02173    | 0.02173    |   0.0 |  0.02
Output  | 5.6716e-05 | 5.6716e-05 | 5.6716e-05 |   0.0 |  0.00
Modify  | 0.12354    | 0.12354    | 0.12354    |   0.0 |  0.12
Other   |            | 0.01042    |            |       |  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:       531846 ave      531846 max      531846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531846
Ave neighs/atom = 132.9615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.349092136876, Press = -1.80550340086466
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.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   
     35000  -13891.398     -13891.398     -14022.628     -14022.628      253.87286      253.87286      48039.196      48039.196     -588.43227     -588.43227    
     36000  -13897.765     -13897.765     -14027.154     -14027.154      250.31088      250.31088      48043.44       48043.44      -1141.0145     -1141.0145    
Loop time of 103.376 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.716 hours/ns, 9.673 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    | 103.22     | 103.22     | 103.22     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.02
Output  | 5.9312e-05 | 5.9312e-05 | 5.9312e-05 |   0.0 |  0.00
Modify  | 0.12338    | 0.12338    | 0.12338    |   0.0 |  0.12
Other   |            | 0.0104     |            |       |  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:       531410 ave      531410 max      531410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531410
Ave neighs/atom = 132.8525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.338206906293, Press = -1.0578206896641
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.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   
     36000  -13897.765     -13897.765     -14027.154     -14027.154      250.31088      250.31088      48043.44       48043.44      -1141.0145     -1141.0145    
     37000  -13895.342     -13895.342     -14026.308     -14026.308      253.36135      253.36135      48021.658      48021.658     -405.54694     -405.54694    
Loop time of 103.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.712 hours/ns, 9.675 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    | 103.21     | 103.21     | 103.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021616   | 0.021616   | 0.021616   |   0.0 |  0.02
Output  | 6.3039e-05 | 6.3039e-05 | 6.3039e-05 |   0.0 |  0.00
Modify  | 0.12364    | 0.12364    | 0.12364    |   0.0 |  0.12
Other   |            | 0.0107     |            |       |  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:       531576 ave      531576 max      531576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531576
Ave neighs/atom = 132.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.336390572256, Press = -0.360794992654007
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.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   
     37000  -13895.342     -13895.342     -14026.308     -14026.308      253.36135      253.36135      48021.658      48021.658     -405.54694     -405.54694    
     38000  -13894.179     -13894.179     -14026.847     -14026.847      256.65481      256.65481      48012.246      48012.246     -205.19601     -205.19601    
Loop time of 103.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.836 ns/day, 28.723 hours/ns, 9.671 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021591   | 0.021591   | 0.021591   |   0.0 |  0.02
Output  | 6.7928e-05 | 6.7928e-05 | 6.7928e-05 |   0.0 |  0.00
Modify  | 0.1229     | 0.1229     | 0.1229     |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  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:       531854 ave      531854 max      531854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0