# 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.613315634429455*${_u_distance}
variable latticeconst_converted equal 3.613315634429455*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331563442945
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.133156 36.133156 36.133156)
  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.133156 36.133156 36.133156)
  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_LeeShim_2004_NiCu__MO_409065472403_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14018.806     -14018.806     -14160         -14160          273.15         273.15         47175.629      47175.629      3196.8326      3196.8326    
      1000  -13870.076     -13870.076     -14014.445     -14014.445      279.29183      279.29183      47934.911      47934.911     -1401.2815     -1401.2815    
Loop time of 35.3588 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.444 ns/day, 9.822 hours/ns, 28.282 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 35.206     | 35.206     | 35.206     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022237   | 0.022237   | 0.022237   |   0.0 |  0.06
Output  | 0.0001624  | 0.0001624  | 0.0001624  |   0.0 |  0.00
Modify  | 0.11925    | 0.11925    | 0.11925    |   0.0 |  0.34
Other   |            | 0.011      |            |       |  0.03

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

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

Performance: 2.247 ns/day, 10.681 hours/ns, 26.006 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    | 38.303     | 38.303     | 38.303     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021799   | 0.021799   | 0.021799   |   0.0 |  0.06
Output  | 8.2505e-05 | 8.2505e-05 | 8.2505e-05 |   0.0 |  0.00
Modify  | 0.1178     | 0.1178     | 0.1178     |   0.0 |  0.31
Other   |            | 0.01025    |            |       |  0.03

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

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

Performance: 2.242 ns/day, 10.703 hours/ns, 25.952 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    | 38.382     | 38.382     | 38.382     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021749   | 0.021749   | 0.021749   |   0.0 |  0.06
Output  | 4.6848e-05 | 4.6848e-05 | 4.6848e-05 |   0.0 |  0.00
Modify  | 0.1177     | 0.1177     | 0.1177     |   0.0 |  0.31
Other   |            | 0.01022    |            |       |  0.03

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

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

Performance: 2.241 ns/day, 10.709 hours/ns, 25.939 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    | 38.402     | 38.402     | 38.402     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021819   | 0.021819   | 0.021819   |   0.0 |  0.06
Output  | 7.2236e-05 | 7.2236e-05 | 7.2236e-05 |   0.0 |  0.00
Modify  | 0.11768    | 0.11768    | 0.11768    |   0.0 |  0.31
Other   |            | 0.01021    |            |       |  0.03

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

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

Performance: 2.243 ns/day, 10.699 hours/ns, 25.963 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    | 38.366     | 38.366     | 38.366     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021743   | 0.021743   | 0.021743   |   0.0 |  0.06
Output  | 3.4926e-05 | 3.4926e-05 | 3.4926e-05 |   0.0 |  0.00
Modify  | 0.11801    | 0.11801    | 0.11801    |   0.0 |  0.31
Other   |            | 0.01019    |            |       |  0.03

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

Total # of neighbors = 311290
Ave neighs/atom = 77.8225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.452432223655, Press = 727.422876393428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13880.22      -13880.22      -14017.363     -14017.363      265.31182      265.31182      47860.951      47860.951      513.55729      513.55729    
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2019      1491.2019    
Loop time of 38.5581 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.241 ns/day, 10.711 hours/ns, 25.935 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    | 38.404     | 38.404     | 38.404     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021826   | 0.021826   | 0.021826   |   0.0 |  0.06
Output  | 4.8811e-05 | 4.8811e-05 | 4.8811e-05 |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  0.32
Other   |            | 0.01025    |            |       |  0.03

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

Total # of neighbors = 311444
Ave neighs/atom = 77.861
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 = 272.610071877583, Press = 17.7903230035211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13874.143     -13874.143     -14020.344     -14020.344      282.83644      282.83644      47823.358      47823.358      1491.2019      1491.2019    
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1871     -1036.1871    
Loop time of 38.5384 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.242 ns/day, 10.705 hours/ns, 25.948 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    | 38.385     | 38.385     | 38.385     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021794   | 0.021794   | 0.021794   |   0.0 |  0.06
Output  | 3.8101e-05 | 3.8101e-05 | 3.8101e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.32
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311504
Ave neighs/atom = 77.876
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.012114567407, Press = -4.48329267606618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13880.514     -13880.514     -14019.502     -14019.502      268.88252      268.88252      47908.507      47908.507     -1036.1871     -1036.1871    
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71987     -711.71987    
Loop time of 38.5179 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.243 ns/day, 10.699 hours/ns, 25.962 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    | 38.364     | 38.364     | 38.364     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021755   | 0.021755   | 0.021755   |   0.0 |  0.06
Output  | 3.722e-05  | 3.722e-05  | 3.722e-05  |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  0.32
Other   |            | 0.01023    |            |       |  0.03

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

Total # of neighbors = 311402
Ave neighs/atom = 77.8505
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 = 273.088072843579, Press = 19.9536962136751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13879.31      -13879.31      -14018.24      -14018.24       268.76918      268.76918      47900.154      47900.154     -711.71987     -711.71987    
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41892      273.41892      47847.43       47847.43       1351.3965      1351.3965    
Loop time of 38.4806 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.245 ns/day, 10.689 hours/ns, 25.987 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    | 38.327     | 38.327     | 38.327     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021709   | 0.021709   | 0.021709   |   0.0 |  0.06
Output  | 5.8059e-05 | 5.8059e-05 | 5.8059e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.32
Other   |            | 0.01029    |            |       |  0.03

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

Total # of neighbors = 311262
Ave neighs/atom = 77.8155
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 = 273.383464358376, Press = 12.2280949127555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13873.264     -13873.264     -14014.598     -14014.598      273.41892      273.41892      47847.43       47847.43       1351.3965      1351.3965    
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42772      394.42772    
Loop time of 38.5665 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.713 hours/ns, 25.929 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    | 38.413     | 38.413     | 38.413     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021662   | 0.021662   | 0.021662   |   0.0 |  0.06
Output  | 5.5715e-05 | 5.5715e-05 | 5.5715e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.31
Other   |            | 0.01025    |            |       |  0.03

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

Total # of neighbors = 311392
Ave neighs/atom = 77.848
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 = 273.298219064675, Press = 4.11256890196492
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13875.848     -13875.848     -14016.169     -14016.169      271.46095      271.46095      47872.004      47872.004      394.42772      394.42772    
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89317      266.89317      47903.178      47903.178     -896.70034     -896.70034    
Loop time of 38.5166 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.243 ns/day, 10.699 hours/ns, 25.963 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    | 38.363     | 38.363     | 38.363     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021801   | 0.021801   | 0.021801   |   0.0 |  0.06
Output  | 3.765e-05  | 3.765e-05  | 3.765e-05  |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.31
Other   |            | 0.01021    |            |       |  0.03

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

Total # of neighbors = 311332
Ave neighs/atom = 77.833
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 = 273.181711162336, Press = 2.01454664889722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13880.74      -13880.74      -14018.7       -14018.7        266.89317      266.89317      47903.178      47903.178     -896.70034     -896.70034    
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45393      272.45393      47887.829      47887.829     -429.55959     -429.55959    
Loop time of 38.4678 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.246 ns/day, 10.685 hours/ns, 25.996 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    | 38.314     | 38.314     | 38.314     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021674   | 0.021674   | 0.021674   |   0.0 |  0.06
Output  | 5.303e-05  | 5.303e-05  | 5.303e-05  |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.32
Other   |            | 0.01027    |            |       |  0.03

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

Total # of neighbors = 311378
Ave neighs/atom = 77.8445
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 = 272.921836123598, Press = 11.4619099269477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13879.029     -13879.029     -14019.863     -14019.863      272.45393      272.45393      47887.829      47887.829     -429.55959     -429.55959    
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.7498       273.7498       47798.836      47798.836      2059.7493      2059.7493    
Loop time of 38.5751 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.715 hours/ns, 25.923 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    | 38.422     | 38.422     | 38.422     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021872   | 0.021872   | 0.021872   |   0.0 |  0.06
Output  | 4.8171e-05 | 4.8171e-05 | 4.8171e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.31
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311470
Ave neighs/atom = 77.8675
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 = 272.939816045504, Press = 2.55582529899432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13879.086     -13879.086     -14020.59      -14020.59       273.7498       273.7498       47798.836      47798.836      2059.7493      2059.7493    
     14000  -13872.139     -13872.139     -14013.705     -14013.705      273.8686       273.8686       47913.932      47913.932     -537.43217     -537.43217    
Loop time of 38.5449 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.242 ns/day, 10.707 hours/ns, 25.944 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    | 38.391     | 38.391     | 38.391     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021694   | 0.021694   | 0.021694   |   0.0 |  0.06
Output  | 8.3757e-05 | 8.3757e-05 | 8.3757e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.32
Other   |            | 0.01022    |            |       |  0.03

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

Total # of neighbors = 311514
Ave neighs/atom = 77.8785
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 = 273.053841617159, Press = 0.99518310820685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13872.139     -13872.139     -14013.705     -14013.705      273.8686       273.8686       47913.932      47913.932     -537.43217     -537.43217    
     15000  -13879.09      -13879.09      -14019.725     -14019.725      272.06702      272.06702      47872.854      47872.854     -93.011886     -93.011886    
Loop time of 38.5071 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.244 ns/day, 10.696 hours/ns, 25.969 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    | 38.353     | 38.353     | 38.353     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021834   | 0.021834   | 0.021834   |   0.0 |  0.06
Output  | 5.0615e-05 | 5.0615e-05 | 5.0615e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.32
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311326
Ave neighs/atom = 77.8315
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 = 273.187708855445, Press = 3.89243967075944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13879.09      -13879.09      -14019.725     -14019.725      272.06702      272.06702      47872.854      47872.854     -93.011886     -93.011886    
     16000  -13882.526     -13882.526     -14022.502     -14022.502      270.79217      270.79217      47843.465      47843.465      497.32467      497.32467    
Loop time of 38.5083 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.244 ns/day, 10.697 hours/ns, 25.968 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    | 38.355     | 38.355     | 38.355     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021739   | 0.021739   | 0.021739   |   0.0 |  0.06
Output  | 4.3282e-05 | 4.3282e-05 | 4.3282e-05 |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.32
Other   |            | 0.01027    |            |       |  0.03

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

Total # of neighbors = 311328
Ave neighs/atom = 77.832
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 = 273.159243349526, Press = 3.81998314564618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13882.526     -13882.526     -14022.502     -14022.502      270.79217      270.79217      47843.465      47843.465      497.32467      497.32467    
     17000  -13874.87      -13874.87      -14016.189     -14016.189      273.39209      273.39209      47860.677      47860.677      750.50227      750.50227    
Loop time of 38.5354 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.242 ns/day, 10.704 hours/ns, 25.950 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    | 38.382     | 38.382     | 38.382     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021706   | 0.021706   | 0.021706   |   0.0 |  0.06
Output  | 3.8191e-05 | 3.8191e-05 | 3.8191e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.32
Other   |            | 0.01029    |            |       |  0.03

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

Total # of neighbors = 311474
Ave neighs/atom = 77.8685
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 = 273.066185050252, Press = 1.51790429886594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13874.87      -13874.87      -14016.189     -14016.189      273.39209      273.39209      47860.677      47860.677      750.50227      750.50227    
     18000  -13878.826     -13878.826     -14019.507     -14019.507      272.15509      272.15509      47903.9        47903.9       -978.93594     -978.93594    
Loop time of 38.5073 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.244 ns/day, 10.696 hours/ns, 25.969 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    | 38.354     | 38.354     | 38.354     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.06
Output  | 4.9764e-05 | 4.9764e-05 | 4.9764e-05 |   0.0 |  0.00
Modify  | 0.12151    | 0.12151    | 0.12151    |   0.0 |  0.32
Other   |            | 0.01025    |            |       |  0.03

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

Total # of neighbors = 311320
Ave neighs/atom = 77.83
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 = 273.204684350225, Press = 0.312241285765854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13878.826     -13878.826     -14019.507     -14019.507      272.15509      272.15509      47903.9        47903.9       -978.93594     -978.93594    
     19000  -13872.781     -13872.781     -14012.984     -14012.984      271.23253      271.23253      47912.244      47912.244     -462.13153     -462.13153    
Loop time of 38.5316 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.242 ns/day, 10.703 hours/ns, 25.953 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    | 38.378     | 38.378     | 38.378     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021762   | 0.021762   | 0.021762   |   0.0 |  0.06
Output  | 3.5997e-05 | 3.5997e-05 | 3.5997e-05 |   0.0 |  0.00
Modify  | 0.12111    | 0.12111    | 0.12111    |   0.0 |  0.31
Other   |            | 0.01023    |            |       |  0.03

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

Total # of neighbors = 311362
Ave neighs/atom = 77.8405
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 = 273.268473965983, Press = 4.24732051230409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13872.781     -13872.781     -14012.984     -14012.984      271.23253      271.23253      47912.244      47912.244     -462.13153     -462.13153    
     20000  -13879.95      -13879.95      -14021.656     -14021.656      274.13995      274.13995      47800.713      47800.713      1841.5037      1841.5037    
Loop time of 38.5824 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.239 ns/day, 10.717 hours/ns, 25.919 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    | 38.429     | 38.429     | 38.429     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021741   | 0.021741   | 0.021741   |   0.0 |  0.06
Output  | 5.0765e-05 | 5.0765e-05 | 5.0765e-05 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.31
Other   |            | 0.01024    |            |       |  0.03

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

Total # of neighbors = 311268
Ave neighs/atom = 77.817
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 = 273.332588152028, Press = 2.31737692374009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13879.95      -13879.95      -14021.656     -14021.656      274.13995      274.13995      47800.713      47800.713      1841.5037      1841.5037    
     21000  -13877.494     -13877.494     -14019.5       -14019.5        274.72002      274.72002      47889.36       47889.36      -368.36832     -368.36832    
Loop time of 38.5421 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.242 ns/day, 10.706 hours/ns, 25.946 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    | 38.389     | 38.389     | 38.389     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021739   | 0.021739   | 0.021739   |   0.0 |  0.06
Output  | 5.0424e-05 | 5.0424e-05 | 5.0424e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.32
Other   |            | 0.01024    |            |       |  0.03

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

Total # of neighbors = 311542
Ave neighs/atom = 77.8855
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 = 273.291359807004, Press = -1.71911594642972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13877.494     -13877.494     -14019.5       -14019.5        274.72002      274.72002      47889.36       47889.36      -368.36832     -368.36832    
     22000  -13878.642     -13878.642     -14018.781     -14018.781      271.10699      271.10699      47930.34       47930.34      -1638.8412     -1638.8412    
Loop time of 38.5578 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.241 ns/day, 10.710 hours/ns, 25.935 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    | 38.404     | 38.404     | 38.404     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021711   | 0.021711   | 0.021711   |   0.0 |  0.06
Output  | 3.723e-05  | 3.723e-05  | 3.723e-05  |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.31
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311422
Ave neighs/atom = 77.8555
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 = 273.256589724048, Press = 2.9376362908196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13878.642     -13878.642     -14018.781     -14018.781      271.10699      271.10699      47930.34       47930.34      -1638.8412     -1638.8412    
     23000  -13878.895     -13878.895     -14017.421     -14017.421      267.98784      267.98784      47846.491      47846.491      984.11097      984.11097    
Loop time of 38.5744 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.715 hours/ns, 25.924 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.421     | 38.421     | 38.421     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021806   | 0.021806   | 0.021806   |   0.0 |  0.06
Output  | 4.9022e-05 | 4.9022e-05 | 4.9022e-05 |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.32
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311354
Ave neighs/atom = 77.8385
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 = 273.13047426061, Press = 3.07779434923162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13878.895     -13878.895     -14017.421     -14017.421      267.98784      267.98784      47846.491      47846.491      984.11097      984.11097    
     24000  -13878.837     -13878.837     -14020.066     -14020.066      273.21767      273.21767      47857.189      47857.189      436.40764      436.40764    
Loop time of 38.5531 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.241 ns/day, 10.709 hours/ns, 25.938 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.4       | 38.4       | 38.4       |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021768   | 0.021768   | 0.021768   |   0.0 |  0.06
Output  | 4.9382e-05 | 4.9382e-05 | 4.9382e-05 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.32
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311468
Ave neighs/atom = 77.867
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 = 273.087075968127, Press = 0.69472967676939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13878.837     -13878.837     -14020.066     -14020.066      273.21767      273.21767      47857.189      47857.189      436.40764      436.40764    
     25000  -13874.302     -13874.302     -14014.875     -14014.875      271.94696      271.94696      47906.137      47906.137     -395.83522     -395.83522    
Loop time of 38.5964 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.239 ns/day, 10.721 hours/ns, 25.909 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.443     | 38.443     | 38.443     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021659   | 0.021659   | 0.021659   |   0.0 |  0.06
Output  | 3.0597e-05 | 3.0597e-05 | 3.0597e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.31
Other   |            | 0.01025    |            |       |  0.03

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

Total # of neighbors = 311450
Ave neighs/atom = 77.8625
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 = 273.063828360589, Press = 0.960708999280371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13874.302     -13874.302     -14014.875     -14014.875      271.94696      271.94696      47906.137      47906.137     -395.83522     -395.83522    
     26000  -13879.254     -13879.254     -14018.122     -14018.122      268.6506       268.6506       47884.518      47884.518     -126.71624     -126.71624    
Loop time of 38.5975 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.238 ns/day, 10.722 hours/ns, 25.908 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.444     | 38.444     | 38.444     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.06
Output  | 4.1268e-05 | 4.1268e-05 | 4.1268e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  0.32
Other   |            | 0.01029    |            |       |  0.03

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

Total # of neighbors = 311358
Ave neighs/atom = 77.8395
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 = 273.141016971386, Press = 3.3671210301507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13879.254     -13879.254     -14018.122     -14018.122      268.6506       268.6506       47884.518      47884.518     -126.71624     -126.71624    
     27000  -13874.108     -13874.108     -14014.923     -14014.923      272.41585      272.41585      47792.655      47792.655      2851.4057      2851.4057    
Loop time of 38.5803 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.239 ns/day, 10.717 hours/ns, 25.920 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.427     | 38.427     | 38.427     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021805   | 0.021805   | 0.021805   |   0.0 |  0.06
Output  | 3.8582e-05 | 3.8582e-05 | 3.8582e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.32
Other   |            | 0.01031    |            |       |  0.03

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

Total # of neighbors = 311464
Ave neighs/atom = 77.866
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 = 273.170087829844, Press = 1.9757966720401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13874.108     -13874.108     -14014.923     -14014.923      272.41585      272.41585      47792.655      47792.655      2851.4057      2851.4057    
     28000  -13878.474     -13878.474     -14018.365     -14018.365      270.63028      270.63028      47891.396      47891.396     -318.09646     -318.09646    
Loop time of 38.5642 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.712 hours/ns, 25.931 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.41      | 38.41      | 38.41      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021959   | 0.021959   | 0.021959   |   0.0 |  0.06
Output  | 3.1008e-05 | 3.1008e-05 | 3.1008e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.31
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311436
Ave neighs/atom = 77.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.251622939477, Press = -0.845880414019677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13878.474     -13878.474     -14018.365     -14018.365      270.63028      270.63028      47891.396      47891.396     -318.09646     -318.09646    
     29000  -13880.137     -13880.137     -14019.422     -14019.422      269.45688      269.45688      47892.361      47892.361     -620.1612      -620.1612     
Loop time of 38.5826 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.239 ns/day, 10.717 hours/ns, 25.918 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.429     | 38.429     | 38.429     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021818   | 0.021818   | 0.021818   |   0.0 |  0.06
Output  | 4.257e-05  | 4.257e-05  | 4.257e-05  |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.31
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311424
Ave neighs/atom = 77.856
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 = 273.261237151218, Press = 1.96079591159849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13880.137     -13880.137     -14019.422     -14019.422      269.45688      269.45688      47892.361      47892.361     -620.1612      -620.1612     
     30000  -13876.623     -13876.623     -14018.258     -14018.258      274.00285      274.00285      47848.765      47848.765      839.08104      839.08104    
Loop time of 38.564 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.712 hours/ns, 25.931 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.41      | 38.41      | 38.41      |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021867   | 0.021867   | 0.021867   |   0.0 |  0.06
Output  | 3.8302e-05 | 3.8302e-05 | 3.8302e-05 |   0.0 |  0.00
Modify  | 0.12177    | 0.12177    | 0.12177    |   0.0 |  0.32
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311446
Ave neighs/atom = 77.8615
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 = 273.251255197957, Press = 1.62341717000709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13876.623     -13876.623     -14018.258     -14018.258      274.00285      274.00285      47848.765      47848.765      839.08104      839.08104    
     31000  -13879.608     -13879.608     -14017.828     -14017.828      267.39577      267.39577      47852.47       47852.47       759.92398      759.92398    
Loop time of 38.6379 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.236 ns/day, 10.733 hours/ns, 25.881 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.484     | 38.484     | 38.484     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021783   | 0.021783   | 0.021783   |   0.0 |  0.06
Output  | 3.0608e-05 | 3.0608e-05 | 3.0608e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.31
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311460
Ave neighs/atom = 77.865
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 = 273.22863595506, Press = 0.839727110485927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13879.608     -13879.608     -14017.828     -14017.828      267.39577      267.39577      47852.47       47852.47       759.92398      759.92398    
     32000  -13876.702     -13876.702     -14015.739     -14015.739      268.97589      268.97589      47915.534      47915.534     -880.89242     -880.89242    
Loop time of 38.6307 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.237 ns/day, 10.731 hours/ns, 25.886 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.477     | 38.477     | 38.477     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021836   | 0.021836   | 0.021836   |   0.0 |  0.06
Output  | 4.0596e-05 | 4.0596e-05 | 4.0596e-05 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.32
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311414
Ave neighs/atom = 77.8535
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 = 273.237840903584, Press = 0.233942617692581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13876.702     -13876.702     -14015.739     -14015.739      268.97589      268.97589      47915.534      47915.534     -880.89242     -880.89242    
     33000  -13881.064     -13881.064     -14020.424     -14020.424      269.60225      269.60225      47882.437      47882.437     -347.46031     -347.46031    
Loop time of 38.5745 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.240 ns/day, 10.715 hours/ns, 25.924 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.421     | 38.421     | 38.421     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021768   | 0.021768   | 0.021768   |   0.0 |  0.06
Output  | 3.0758e-05 | 3.0758e-05 | 3.0758e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.32
Other   |            | 0.01024    |            |       |  0.03

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

Total # of neighbors = 311338
Ave neighs/atom = 77.8345
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 = 273.20620259213, Press = 2.79095363918112
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13881.064     -13881.064     -14020.424     -14020.424      269.60225      269.60225      47882.437      47882.437     -347.46031     -347.46031    
     34000  -13876.352     -13876.352     -14018.953     -14018.953      275.87197      275.87197      47832.673      47832.673      1321.8287      1321.8287    
Loop time of 38.6177 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.237 ns/day, 10.727 hours/ns, 25.895 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.464     | 38.464     | 38.464     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02191    | 0.02191    | 0.02191    |   0.0 |  0.06
Output  | 4.1728e-05 | 4.1728e-05 | 4.1728e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  0.32
Other   |            | 0.01026    |            |       |  0.03

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

Total # of neighbors = 311468
Ave neighs/atom = 77.867
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 = 273.189269795958, Press = 1.30820831361991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13876.352     -13876.352     -14018.953     -14018.953      275.87197      275.87197      47832.673      47832.673      1321.8287      1321.8287    
     35000  -13881.088     -13881.088     -14021.583     -14021.583      271.79699      271.79699      47855.105      47855.105      291.71769      291.71769    
Loop time of 38.6302 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.237 ns/day, 10.731 hours/ns, 25.887 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.476     | 38.476     | 38.476     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021906   | 0.021906   | 0.021906   |   0.0 |  0.06
Output  | 4.1428e-05 | 4.1428e-05 | 4.1428e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.31
Other   |            | 0.01028    |            |       |  0.03

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

Total # of neighbors = 311490
Ave neighs/atom = 77.8725
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
47876.1599542641

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0