# 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.003 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_LeeShimBaskes_2003_Cu__MO_087820130586_001
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_087820130586_001#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 191.548 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.451 ns/day, 53.208 hours/ns, 5.221 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.65     | 190.65     | 190.65     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1479     | 0.1479     | 0.1479     |   0.0 |  0.08
Output  | 0.00024248 | 0.00024248 | 0.00024248 |   0.0 |  0.00
Modify  | 0.65629    | 0.65629    | 0.65629    |   0.0 |  0.34
Other   |            | 0.09471    |            |       |  0.05

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 198.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.212 hours/ns, 5.031 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.89     | 197.89     | 197.89     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14458    | 0.14458    | 0.14458    |   0.0 |  0.07
Output  | 0.00023638 | 0.00023638 | 0.00023638 |   0.0 |  0.00
Modify  | 0.63904    | 0.63904    | 0.63904    |   0.0 |  0.32
Other   |            | 0.09373    |            |       |  0.05

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 199.066 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.296 hours/ns, 5.023 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.19     | 198.19     | 198.19     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14574    | 0.14574    | 0.14574    |   0.0 |  0.07
Output  | 0.00028692 | 0.00028692 | 0.00028692 |   0.0 |  0.00
Modify  | 0.63808    | 0.63808    | 0.63808    |   0.0 |  0.32
Other   |            | 0.09311    |            |       |  0.05

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 198.85 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.236 hours/ns, 5.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.97     | 197.97     | 197.97     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14485    | 0.14485    | 0.14485    |   0.0 |  0.07
Output  | 0.00023696 | 0.00023696 | 0.00023696 |   0.0 |  0.00
Modify  | 0.63918    | 0.63918    | 0.63918    |   0.0 |  0.32
Other   |            | 0.09355    |            |       |  0.05

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 198.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.207 hours/ns, 5.032 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.87     | 197.87     | 197.87     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14412    | 0.14412    | 0.14412    |   0.0 |  0.07
Output  | 0.00018907 | 0.00018907 | 0.00018907 |   0.0 |  0.00
Modify  | 0.64162    | 0.64162    | 0.64162    |   0.0 |  0.32
Other   |            | 0.09343    |            |       |  0.05

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 198.976 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.271 hours/ns, 5.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.07     | 198.07     | 198.07     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1452     | 0.1452     | 0.1452     |   0.0 |  0.07
Output  | 0.00019194 | 0.00019194 | 0.00019194 |   0.0 |  0.00
Modify  | 0.66453    | 0.66453    | 0.66453    |   0.0 |  0.33
Other   |            | 0.09288    |            |       |  0.05

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 198.977 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.271 hours/ns, 5.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.07     | 198.07     | 198.07     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1445     | 0.1445     | 0.1445     |   0.0 |  0.07
Output  | 0.00019198 | 0.00019198 | 0.00019198 |   0.0 |  0.00
Modify  | 0.6658     | 0.6658     | 0.6658     |   0.0 |  0.33
Other   |            | 0.09312    |            |       |  0.05

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 198.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.211 hours/ns, 5.031 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.85     | 197.85     | 197.85     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14547    | 0.14547    | 0.14547    |   0.0 |  0.07
Output  | 0.00023022 | 0.00023022 | 0.00023022 |   0.0 |  0.00
Modify  | 0.6652     | 0.6652     | 0.6652     |   0.0 |  0.33
Other   |            | 0.09275    |            |       |  0.05

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 198.753 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.209 hours/ns, 5.031 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.85     | 197.85     | 197.85     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14632    | 0.14632    | 0.14632    |   0.0 |  0.07
Output  | 0.00019038 | 0.00019038 | 0.00019038 |   0.0 |  0.00
Modify  | 0.66589    | 0.66589    | 0.66589    |   0.0 |  0.34
Other   |            | 0.09282    |            |       |  0.05

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 203.575 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.549 hours/ns, 4.912 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.64     | 202.64     | 202.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15007    | 0.15007    | 0.15007    |   0.0 |  0.07
Output  | 0.00019053 | 0.00019053 | 0.00019053 |   0.0 |  0.00
Modify  | 0.69237    | 0.69237    | 0.69237    |   0.0 |  0.34
Other   |            | 0.09388    |            |       |  0.05

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 202.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.356 hours/ns, 4.929 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.94     | 201.94     | 201.94     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14768    | 0.14768    | 0.14768    |   0.0 |  0.07
Output  | 0.00022688 | 0.00022688 | 0.00022688 |   0.0 |  0.00
Modify  | 0.69615    | 0.69615    | 0.69615    |   0.0 |  0.34
Other   |            | 0.09603    |            |       |  0.05

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 198.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.167 hours/ns, 5.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.7      | 197.7      | 197.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1464     | 0.1464     | 0.1464     |   0.0 |  0.07
Output  | 0.0001944  | 0.0001944  | 0.0001944  |   0.0 |  0.00
Modify  | 0.66614    | 0.66614    | 0.66614    |   0.0 |  0.34
Other   |            | 0.09329    |            |       |  0.05

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 200.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.611 hours/ns, 4.995 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.29     | 199.29     | 199.29     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14499    | 0.14499    | 0.14499    |   0.0 |  0.07
Output  | 0.00018977 | 0.00018977 | 0.00018977 |   0.0 |  0.00
Modify  | 0.67107    | 0.67107    | 0.67107    |   0.0 |  0.34
Other   |            | 0.09378    |            |       |  0.05

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 199.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.504 hours/ns, 5.005 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.9      | 198.9      | 198.9      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14593    | 0.14593    | 0.14593    |   0.0 |  0.07
Output  | 0.00061413 | 0.00061413 | 0.00061413 |   0.0 |  0.00
Modify  | 0.67002    | 0.67002    | 0.67002    |   0.0 |  0.34
Other   |            | 0.09435    |            |       |  0.05

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 218.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.818 hours/ns, 4.567 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.93     | 217.93     | 217.93     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15503    | 0.15503    | 0.15503    |   0.0 |  0.07
Output  | 0.00019359 | 0.00019359 | 0.00019359 |   0.0 |  0.00
Modify  | 0.75483    | 0.75483    | 0.75483    |   0.0 |  0.34
Other   |            | 0.1        |            |       |  0.05

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 209.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.411 ns/day, 58.324 hours/ns, 4.763 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.99     | 208.99     | 208.99     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15325    | 0.15325    | 0.15325    |   0.0 |  0.07
Output  | 0.00022537 | 0.00022537 | 0.00022537 |   0.0 |  0.00
Modify  | 0.72677    | 0.72677    | 0.72677    |   0.0 |  0.35
Other   |            | 0.09764    |            |       |  0.05

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 211.194 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.665 hours/ns, 4.735 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.22     | 210.22     | 210.22     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15159    | 0.15159    | 0.15159    |   0.0 |  0.07
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.7242     | 0.7242     | 0.7242     |   0.0 |  0.34
Other   |            | 0.09846    |            |       |  0.05

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 209.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.412 ns/day, 58.289 hours/ns, 4.766 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 208.86     | 208.86     | 208.86     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15332    | 0.15332    | 0.15332    |   0.0 |  0.07
Output  | 0.000192   | 0.000192   | 0.000192   |   0.0 |  0.00
Modify  | 0.72654    | 0.72654    | 0.72654    |   0.0 |  0.35
Other   |            | 0.09719    |            |       |  0.05

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 203.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.460 hours/ns, 4.920 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.33     | 202.33     | 202.33     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14809    | 0.14809    | 0.14809    |   0.0 |  0.07
Output  | 0.0003136  | 0.0003136  | 0.0003136  |   0.0 |  0.00
Modify  | 0.68313    | 0.68313    | 0.68313    |   0.0 |  0.34
Other   |            | 0.09406    |            |       |  0.05

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 230.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 64.062 hours/ns, 4.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.52     | 229.52     | 229.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16384    | 0.16384    | 0.16384    |   0.0 |  0.07
Output  | 0.00031243 | 0.00031243 | 0.00031243 |   0.0 |  0.00
Modify  | 0.83329    | 0.83329    | 0.83329    |   0.0 |  0.36
Other   |            | 0.1063     |            |       |  0.05

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 200.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.749 hours/ns, 4.983 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.78     | 199.78     | 199.78     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14654    | 0.14654    | 0.14654    |   0.0 |  0.07
Output  | 0.00019283 | 0.00019283 | 0.00019283 |   0.0 |  0.00
Modify  | 0.67188    | 0.67188    | 0.67188    |   0.0 |  0.33
Other   |            | 0.09385    |            |       |  0.05

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 223.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.386 ns/day, 62.116 hours/ns, 4.472 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.57     | 222.57     | 222.57     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16047    | 0.16047    | 0.16047    |   0.0 |  0.07
Output  | 0.0001926  | 0.0001926  | 0.0001926  |   0.0 |  0.00
Modify  | 0.78101    | 0.78101    | 0.78101    |   0.0 |  0.35
Other   |            | 0.1022     |            |       |  0.05

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 228.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.355 hours/ns, 4.384 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.97     | 226.97     | 226.97     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16391    | 0.16391    | 0.16391    |   0.0 |  0.07
Output  | 0.00026242 | 0.00026242 | 0.00026242 |   0.0 |  0.00
Modify  | 0.83287    | 0.83287    | 0.83287    |   0.0 |  0.37
Other   |            | 0.1059     |            |       |  0.05

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 201.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.876 hours/ns, 4.971 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.24     | 200.24     | 200.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14801    | 0.14801    | 0.14801    |   0.0 |  0.07
Output  | 0.00020214 | 0.00020214 | 0.00020214 |   0.0 |  0.00
Modify  | 0.6773     | 0.6773     | 0.6773     |   0.0 |  0.34
Other   |            | 0.0939     |            |       |  0.05

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 199.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.295 hours/ns, 5.024 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.15     | 198.15     | 198.15     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14515    | 0.14515    | 0.14515    |   0.0 |  0.07
Output  | 0.0001907  | 0.0001907  | 0.0001907  |   0.0 |  0.00
Modify  | 0.668      | 0.668      | 0.668      |   0.0 |  0.34
Other   |            | 0.094      |            |       |  0.05

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 200.463 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.684 hours/ns, 4.988 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.55     | 199.55     | 199.55     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14353    | 0.14353    | 0.14353    |   0.0 |  0.07
Output  | 0.00026541 | 0.00026541 | 0.00026541 |   0.0 |  0.00
Modify  | 0.67431    | 0.67431    | 0.67431    |   0.0 |  0.34
Other   |            | 0.09679    |            |       |  0.05

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 230.025 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.376 ns/day, 63.896 hours/ns, 4.347 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.97     | 228.97     | 228.97     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16049    | 0.16049    | 0.16049    |   0.0 |  0.07
Output  | 0.00019393 | 0.00019393 | 0.00019393 |   0.0 |  0.00
Modify  | 0.79502    | 0.79502    | 0.79502    |   0.0 |  0.35
Other   |            | 0.1032     |            |       |  0.04

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 216.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.171 hours/ns, 4.616 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 215.57     | 215.57     | 215.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15755    | 0.15755    | 0.15755    |   0.0 |  0.07
Output  | 0.00024276 | 0.00024276 | 0.00024276 |   0.0 |  0.00
Modify  | 0.78676    | 0.78676    | 0.78676    |   0.0 |  0.36
Other   |            | 0.1041     |            |       |  0.05

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 233.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.928 hours/ns, 4.278 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.64     | 232.64     | 232.64     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1636     | 0.1636     | 0.1636     |   0.0 |  0.07
Output  | 0.00019255 | 0.00019255 | 0.00019255 |   0.0 |  0.00
Modify  | 0.83267    | 0.83267    | 0.83267    |   0.0 |  0.36
Other   |            | 0.1064     |            |       |  0.05

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 234.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.151 hours/ns, 4.264 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.43     | 233.43     | 233.43     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16683    | 0.16683    | 0.16683    |   0.0 |  0.07
Output  | 0.00019288 | 0.00019288 | 0.00019288 |   0.0 |  0.00
Modify  | 0.84437    | 0.84437    | 0.84437    |   0.0 |  0.36
Other   |            | 0.1068     |            |       |  0.05

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 227.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.245 hours/ns, 4.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.58     | 226.58     | 226.58     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16242    | 0.16242    | 0.16242    |   0.0 |  0.07
Output  | 0.0001918  | 0.0001918  | 0.0001918  |   0.0 |  0.00
Modify  | 0.83304    | 0.83304    | 0.83304    |   0.0 |  0.37
Other   |            | 0.1063     |            |       |  0.05

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 233.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.971 hours/ns, 4.275 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.76     | 232.76     | 232.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16667    | 0.16667    | 0.16667    |   0.0 |  0.07
Output  | 0.00019131 | 0.00019131 | 0.00019131 |   0.0 |  0.00
Modify  | 0.86487    | 0.86487    | 0.86487    |   0.0 |  0.37
Other   |            | 0.1076     |            |       |  0.05

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 222.139 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.705 hours/ns, 4.502 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.07     | 221.07     | 221.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15888    | 0.15888    | 0.15888    |   0.0 |  0.07
Output  | 0.00019331 | 0.00019331 | 0.00019331 |   0.0 |  0.00
Modify  | 0.80147    | 0.80147    | 0.80147    |   0.0 |  0.36
Other   |            | 0.104      |            |       |  0.05

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 222.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.682 hours/ns, 4.503 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.01     | 221.01     | 221.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15836    | 0.15836    | 0.15836    |   0.0 |  0.07
Output  | 0.00026014 | 0.00026014 | 0.00026014 |   0.0 |  0.00
Modify  | 0.78756    | 0.78756    | 0.78756    |   0.0 |  0.35
Other   |            | 0.1026     |            |       |  0.05

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 218.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.575 hours/ns, 4.586 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.05     | 217.05     | 217.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15669    | 0.15669    | 0.15669    |   0.0 |  0.07
Output  | 0.0001952  | 0.0001952  | 0.0001952  |   0.0 |  0.00
Modify  | 0.76218    | 0.76218    | 0.76218    |   0.0 |  0.35
Other   |            | 0.09814    |            |       |  0.05

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