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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.613315671682358*${_u_distance}
variable latticeconst_converted equal 3.613315671682358*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331567168236
Lattice spacing in x,y,z = 3.6133157 3.6133157 3.6133157
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133157 36.133157 36.133157)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133157 36.133157 36.133157)
  create_atoms CPU = 0.008 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_JeongParkDo_2018_PdCu__MO_353393547686_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.6305927869    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*1*${_u_distance})
variable      V0_metal equal 47175.6305927869/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6305927869*1000

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

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

variable temp_converted equal 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_353393547686_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.631    47175.631    3196.8187    3196.8187 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2832   -1401.2832 
Loop time of 266.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.324 ns/day, 73.976 hours/ns, 3.755 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    | 265.39     | 265.39     | 265.39     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.06
Output  | 0.0002623  | 0.0002623  | 0.0002623  |   0.0 |  0.00
Modify  | 0.68299    | 0.68299    | 0.68299    |   0.0 |  0.26
Other   |            | 0.09706    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.000000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.2832   -1401.2832 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88556    275.88556    47875.069    47875.069   -480.35182   -480.35182 
Loop time of 264.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.405 hours/ns, 3.784 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    | 263.36     | 263.36     | 263.36     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14402    | 0.14402    | 0.14402    |   0.0 |  0.05
Output  | 0.00025391 | 0.00025391 | 0.00025391 |   0.0 |  0.00
Modify  | 0.65267    | 0.65267    | 0.65267    |   0.0 |  0.25
Other   |            | 0.09651    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343568.0 ave      343568 max      343568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343568
Ave neighs/atom = 85.892000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.88556    275.88556    47875.069    47875.069   -480.35182   -480.35182 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83332   -639.83332 
Loop time of 260.282 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.301 hours/ns, 3.842 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    | 259.41     | 259.41     | 259.41     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14044    | 0.14044    | 0.14044    |   0.0 |  0.05
Output  | 0.00021039 | 0.00021039 | 0.00021039 |   0.0 |  0.00
Modify  | 0.63912    | 0.63912    | 0.63912    |   0.0 |  0.25
Other   |            | 0.09604    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343690.0 ave      343690 max      343690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343690
Ave neighs/atom = 85.922500
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.83332   -639.83332 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44925   -856.44925 
Loop time of 272.66 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.739 hours/ns, 3.668 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    | 271.73     | 271.73     | 271.73     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14986    | 0.14986    | 0.14986    |   0.0 |  0.05
Output  | 0.00021457 | 0.00021457 | 0.00021457 |   0.0 |  0.00
Modify  | 0.68778    | 0.68778    | 0.68778    |   0.0 |  0.25
Other   |            | 0.09556    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343756.0 ave      343756 max      343756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343756
Ave neighs/atom = 85.939000
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
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.44925   -856.44925 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31182    265.31182    47860.951    47860.951    513.55667    513.55667 
Loop time of 259.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.079 hours/ns, 3.854 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    | 258.61     | 258.61     | 258.61     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14037    | 0.14037    | 0.14037    |   0.0 |  0.05
Output  | 0.00017645 | 0.00017645 | 0.00017645 |   0.0 |  0.00
Modify  | 0.63898    | 0.63898    | 0.63898    |   0.0 |  0.25
Other   |            | 0.09386    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343672.0 ave      343672 max      343672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343672
Ave neighs/atom = 85.918000
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.452431287086, Press = 727.424001687052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.55667    513.55667 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358     1491.204     1491.204 
Loop time of 301.068 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.630 hours/ns, 3.322 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    | 299.97     | 299.97     | 299.97     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16335    | 0.16335    | 0.16335    |   0.0 |  0.05
Output  | 0.00017859 | 0.00017859 | 0.00017859 |   0.0 |  0.00
Modify  | 0.83011    | 0.83011    | 0.83011    |   0.0 |  0.28
Other   |            | 0.1054     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343712.0 ave      343712 max      343712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343712
Ave neighs/atom = 85.928000
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.610072039201, Press = 17.790371009979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.204     1491.204 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1849   -1036.1849 
Loop time of 273.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.316 ns/day, 75.985 hours/ns, 3.656 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    | 272.58     | 272.58     | 272.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.06
Output  | 0.00021547 | 0.00021547 | 0.00021547 |   0.0 |  0.00
Modify  | 0.72055    | 0.72055    | 0.72055    |   0.0 |  0.26
Other   |            | 0.09658    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343826.0 ave      343826 max      343826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343826
Ave neighs/atom = 85.956500
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.012114513626, Press = -4.48327468305879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.1849   -1036.1849 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154    -711.7188    -711.7188 
Loop time of 303.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.287 hours/ns, 3.296 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    | 302.32     | 302.32     | 302.32     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1635     | 0.1635     | 0.1635     |   0.0 |  0.05
Output  | 0.00030108 | 0.00030108 | 0.00030108 |   0.0 |  0.00
Modify  | 0.84528    | 0.84528    | 0.84528    |   0.0 |  0.28
Other   |            | 0.1066     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343610.0 ave      343610 max      343610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343610
Ave neighs/atom = 85.902500
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.088072357529, Press = 19.9536784160563
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.7188    -711.7188 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41891    273.41891     47847.43     47847.43    1351.3929    1351.3929 
Loop time of 303.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.222 hours/ns, 3.298 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    | 302.09     | 302.09     | 302.09     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16293    | 0.16293    | 0.16293    |   0.0 |  0.05
Output  | 0.00017806 | 0.00017806 | 0.00017806 |   0.0 |  0.00
Modify  | 0.83895    | 0.83895    | 0.83895    |   0.0 |  0.28
Other   |            | 0.1065     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343658.0 ave      343658 max      343658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343658
Ave neighs/atom = 85.914500
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.383463877217, Press = 12.2281084969827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.41891    273.41891     47847.43     47847.43    1351.3929    1351.3929 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46095    271.46095    47872.004    47872.004    394.42844    394.42844 
Loop time of 301.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.286 ns/day, 83.797 hours/ns, 3.315 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    | 300.55     | 300.55     | 300.55     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16455    | 0.16455    | 0.16455    |   0.0 |  0.05
Output  | 0.00017547 | 0.00017547 | 0.00017547 |   0.0 |  0.00
Modify  | 0.85266    | 0.85266    | 0.85266    |   0.0 |  0.28
Other   |            | 0.1071     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343738.0 ave      343738 max      343738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343738
Ave neighs/atom = 85.934500
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.298219098017, Press = 4.11257919181163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.42844    394.42844 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.69849   -896.69849 
Loop time of 299.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.289 ns/day, 83.181 hours/ns, 3.339 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    | 298.34     | 298.34     | 298.34     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16147    | 0.16147    | 0.16147    |   0.0 |  0.05
Output  | 0.00022424 | 0.00022424 | 0.00022424 |   0.0 |  0.00
Modify  | 0.83855    | 0.83855    | 0.83855    |   0.0 |  0.28
Other   |            | 0.1065     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343720.0 ave      343720 max      343720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343720
Ave neighs/atom = 85.930000
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.181711567828, Press = 2.01454353005512
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.89318    266.89318    47903.178    47903.178   -896.69849   -896.69849 
   12000   -13879.029   -13879.029   -14019.863   -14019.863    272.45384    272.45384    47887.829    47887.829   -429.56877   -429.56877 
Loop time of 289.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.298 ns/day, 80.411 hours/ns, 3.454 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    | 288.44     | 288.44     | 288.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15706    | 0.15706    | 0.15706    |   0.0 |  0.05
Output  | 0.00022711 | 0.00022711 | 0.00022711 |   0.0 |  0.00
Modify  | 0.78218    | 0.78218    | 0.78218    |   0.0 |  0.27
Other   |            | 0.1036     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343706.0 ave      343706 max      343706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343706
Ave neighs/atom = 85.926500
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.921833684026, Press = 11.4618975849587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.45384    272.45384    47887.829    47887.829   -429.56877   -429.56877 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74982    273.74982    47798.836    47798.836    2059.7704    2059.7704 
Loop time of 305.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.817 hours/ns, 3.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    | 304.21     | 304.21     | 304.21     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16528    | 0.16528    | 0.16528    |   0.0 |  0.05
Output  | 0.00017868 | 0.00017868 | 0.00017868 |   0.0 |  0.00
Modify  | 0.86112    | 0.86112    | 0.86112    |   0.0 |  0.28
Other   |            | 0.108      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343642.0 ave      343642 max      343642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343642
Ave neighs/atom = 85.910500
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.939827904045, Press = 2.55596846407452
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.74982    273.74982    47798.836    47798.836    2059.7704    2059.7704 
   14000   -13872.136   -13872.136   -14013.703   -14013.703    273.87137    273.87137    47913.946    47913.946   -537.58094   -537.58094 
Loop time of 275.462 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.314 ns/day, 76.517 hours/ns, 3.630 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    | 274.49     | 274.49     | 274.49     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14949    | 0.14949    | 0.14949    |   0.0 |  0.05
Output  | 0.00017657 | 0.00017657 | 0.00017657 |   0.0 |  0.00
Modify  | 0.72886    | 0.72886    | 0.72886    |   0.0 |  0.26
Other   |            | 0.0982     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343808.0 ave      343808 max      343808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343808
Ave neighs/atom = 85.952000
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.053930213056, Press = 0.995008292020519
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13872.136   -13872.136   -14013.703   -14013.703    273.87137    273.87137    47913.946    47913.946   -537.58094   -537.58094 
   15000   -13879.085   -13879.085   -14019.722   -14019.722    272.07213    272.07213    47872.852    47872.852   -92.602276   -92.602276 
Loop time of 260.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.318 hours/ns, 3.841 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    | 259.44     | 259.44     | 259.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14537    | 0.14537    | 0.14537    |   0.0 |  0.06
Output  | 0.00041146 | 0.00041146 | 0.00041146 |   0.0 |  0.00
Modify  | 0.66386    | 0.66386    | 0.66386    |   0.0 |  0.25
Other   |            | 0.09239    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343788.0 ave      343788 max      343788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343788
Ave neighs/atom = 85.947000
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.187715971198, Press = 3.89370543906118
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13879.085   -13879.085   -14019.722   -14019.722    272.07213    272.07213    47872.852    47872.852   -92.602276   -92.602276 
   16000   -13882.539   -13882.539   -14022.508   -14022.508    270.77963    270.77963    47843.484    47843.484    495.99007    495.99007 
Loop time of 298.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.885 hours/ns, 3.351 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    | 297.29     | 297.29     | 297.29     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16212    | 0.16212    | 0.16212    |   0.0 |  0.05
Output  | 0.00017721 | 0.00017721 | 0.00017721 |   0.0 |  0.00
Modify  | 0.82772    | 0.82772    | 0.82772    |   0.0 |  0.28
Other   |            | 0.1063     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343722.0 ave      343722 max      343722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343722
Ave neighs/atom = 85.930500
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.159060835708, Press = 3.81796288775548
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13882.539   -13882.539   -14022.508   -14022.508    270.77963    270.77963    47843.484    47843.484    495.99007    495.99007 
   17000   -13874.853   -13874.853    -14016.18    -14016.18    273.40679    273.40679    47860.764    47860.764    749.20264    749.20264 
Loop time of 303.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.225 hours/ns, 3.298 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    | 302.05     | 302.05     | 302.05     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16797    | 0.16797    | 0.16797    |   0.0 |  0.06
Output  | 0.0002196  | 0.0002196  | 0.0002196  |   0.0 |  0.00
Modify  | 0.88443    | 0.88443    | 0.88443    |   0.0 |  0.29
Other   |            | 0.1102     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343708.0 ave      343708 max      343708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343708
Ave neighs/atom = 85.927000
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.066305000991, Press = 1.52336407427009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13874.853   -13874.853    -14016.18    -14016.18    273.40679    273.40679    47860.764    47860.764    749.20264    749.20264 
   18000   -13878.764   -13878.764   -14019.439   -14019.439    272.14595    272.14595    47906.717    47906.717   -1051.9313   -1051.9313 
Loop time of 298.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.289 ns/day, 83.030 hours/ns, 3.345 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    | 297.8      | 297.8      | 297.8      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16287    | 0.16287    | 0.16287    |   0.0 |  0.05
Output  | 0.00017903 | 0.00017903 | 0.00017903 |   0.0 |  0.00
Modify  | 0.83604    | 0.83604    | 0.83604    |   0.0 |  0.28
Other   |            | 0.106      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343722.0 ave      343722 max      343722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343722
Ave neighs/atom = 85.930500
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.203539886801, Press = 0.333787239188638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13878.764   -13878.764   -14019.439   -14019.439    272.14595    272.14595    47906.717    47906.717   -1051.9313   -1051.9313 
   19000   -13872.589   -13872.589   -14012.888   -14012.888    271.41863    271.41863     47911.28     47911.28   -421.46919   -421.46919 
Loop time of 303.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.368 hours/ns, 3.292 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    | 302.6      | 302.6      | 302.6      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16359    | 0.16359    | 0.16359    |   0.0 |  0.05
Output  | 0.00022629 | 0.00022629 | 0.00022629 |   0.0 |  0.00
Modify  | 0.85165    | 0.85165    | 0.85165    |   0.0 |  0.28
Other   |            | 0.1067     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343730.0 ave      343730 max      343730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343730
Ave neighs/atom = 85.932500
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.272238280556, Press = 4.28065061282094
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13872.589   -13872.589   -14012.888   -14012.888    271.41863    271.41863     47911.28     47911.28   -421.46919   -421.46919 
   20000   -13877.086   -13877.086    -14020.13    -14020.13    276.72762    276.72762    47808.919    47808.919    1809.0131    1809.0131 
Loop time of 301.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.626 hours/ns, 3.322 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    | 299.94     | 299.94     | 299.94     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16326    | 0.16326    | 0.16326    |   0.0 |  0.05
Output  | 0.00018044 | 0.00018044 | 0.00018044 |   0.0 |  0.00
Modify  | 0.84149    | 0.84149    | 0.84149    |   0.0 |  0.28
Other   |            | 0.1074     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343668.0 ave      343668 max      343668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343668
Ave neighs/atom = 85.917000
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.270222013251, Press = 2.71432755447776
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13877.086   -13877.086    -14020.13    -14020.13    276.72762    276.72762    47808.919    47808.919    1809.0131    1809.0131 
   21000   -13878.065   -13878.065   -14019.993   -14019.993    274.56775    274.56775    47879.458    47879.458   -138.88877   -138.88877 
Loop time of 260.944 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.484 hours/ns, 3.832 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    | 260.04     | 260.04     | 260.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14649    | 0.14649    | 0.14649    |   0.0 |  0.06
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.66761    | 0.66761    | 0.66761    |   0.0 |  0.26
Other   |            | 0.09331    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343750.0 ave      343750 max      343750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343750
Ave neighs/atom = 85.937500
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.245168773881, Press = -1.78983725196754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13878.065   -13878.065   -14019.993   -14019.993    274.56775    274.56775    47879.458    47879.458   -138.88877   -138.88877 
   22000   -13876.888   -13876.888   -14017.915   -14017.915    272.82507    272.82507    47937.422    47937.422   -1723.7925   -1723.7925 
Loop time of 260.792 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.442 hours/ns, 3.834 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    | 259.89     | 259.89     | 259.89     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14585    | 0.14585    | 0.14585    |   0.0 |  0.06
Output  | 0.00018039 | 0.00018039 | 0.00018039 |   0.0 |  0.00
Modify  | 0.66629    | 0.66629    | 0.66629    |   0.0 |  0.26
Other   |            | 0.09313    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343702.0 ave      343702 max      343702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343702
Ave neighs/atom = 85.925500
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.286037241619, Press = 2.50248992506113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13876.888   -13876.888   -14017.915   -14017.915    272.82507    272.82507    47937.422    47937.422   -1723.7925   -1723.7925 
   23000   -13873.107   -13873.107   -14014.304   -14014.304    273.15454    273.15454     47865.51     47865.51    849.57162    849.57162 
Loop time of 260.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.415 hours/ns, 3.836 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    | 259.79     | 259.79     | 259.79     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14576    | 0.14576    | 0.14576    |   0.0 |  0.06
Output  | 0.00018035 | 0.00018035 | 0.00018035 |   0.0 |  0.00
Modify  | 0.66792    | 0.66792    | 0.66792    |   0.0 |  0.26
Other   |            | 0.09317    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343668.0 ave      343668 max      343668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343668
Ave neighs/atom = 85.917000
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.285287042427, Press = 2.97889866444816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13873.107   -13873.107   -14014.304   -14014.304    273.15454    273.15454     47865.51     47865.51    849.57162    849.57162 
   24000   -13878.763   -13878.763   -14020.133   -14020.133    273.48833    273.48833    47857.272    47857.272    432.35173    432.35173 
Loop time of 260.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.440 hours/ns, 3.835 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    | 259.88     | 259.88     | 259.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14634    | 0.14634    | 0.14634    |   0.0 |  0.06
Output  | 0.00018164 | 0.00018164 | 0.00018164 |   0.0 |  0.00
Modify  | 0.66753    | 0.66753    | 0.66753    |   0.0 |  0.26
Other   |            | 0.09289    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343784.0 ave      343784 max      343784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343784
Ave neighs/atom = 85.946000
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.385396420145, Press = 1.03091662078251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13878.763   -13878.763   -14020.133   -14020.133    273.48833    273.48833    47857.272    47857.272    432.35173    432.35173 
   25000   -13877.556   -13877.556   -14016.494   -14016.494    268.78522    268.78522    47901.712    47901.712   -484.32847   -484.32847 
Loop time of 261.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.525 hours/ns, 3.830 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    | 260.18     | 260.18     | 260.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14628    | 0.14628    | 0.14628    |   0.0 |  0.06
Output  | 0.00017962 | 0.00017962 | 0.00017962 |   0.0 |  0.00
Modify  | 0.66636    | 0.66636    | 0.66636    |   0.0 |  0.26
Other   |            | 0.09302    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343756.0 ave      343756 max      343756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343756
Ave neighs/atom = 85.939000
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.383729335024, Press = 0.897451352152771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13877.556   -13877.556   -14016.494   -14016.494    268.78522    268.78522    47901.712    47901.712   -484.32847   -484.32847 
   26000   -13880.497   -13880.497    -14018.85    -14018.85    267.65266    267.65266    47879.242    47879.242   -71.410041   -71.410041 
Loop time of 264.501 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.473 hours/ns, 3.781 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    | 263.58     | 263.58     | 263.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14777    | 0.14777    | 0.14777    |   0.0 |  0.06
Output  | 0.00024312 | 0.00024312 | 0.00024312 |   0.0 |  0.00
Modify  | 0.68003    | 0.68003    | 0.68003    |   0.0 |  0.26
Other   |            | 0.09388    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343620.0 ave      343620 max      343620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343620
Ave neighs/atom = 85.905000
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.367577911838, Press = 4.12586380231392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13880.497   -13880.497    -14018.85    -14018.85    267.65266    267.65266    47879.242    47879.242   -71.410041   -71.410041 
   27000   -13875.776   -13875.776    -14015.86    -14015.86    271.00215    271.00215    47791.272    47791.272    2770.8038    2770.8038 
Loop time of 303.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.222 hours/ns, 3.298 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    | 302.07     | 302.07     | 302.07     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.166      | 0.166      | 0.166      |   0.0 |  0.05
Output  | 0.00022127 | 0.00022127 | 0.00022127 |   0.0 |  0.00
Modify  | 0.85495    | 0.85495    | 0.85495    |   0.0 |  0.28
Other   |            | 0.108      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343768.0 ave      343768 max      343768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343768
Ave neighs/atom = 85.942000
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.309070399456, Press = 1.43300412414978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13875.776   -13875.776    -14015.86    -14015.86    271.00215    271.00215    47791.272    47791.272    2770.8038    2770.8038 
   28000   -13882.102   -13882.102    -14020.31    -14020.31    267.37358    267.37358    47887.043    47887.043   -453.24449   -453.24449 
Loop time of 274.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.183 hours/ns, 3.646 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    | 273.29     | 273.29     | 273.29     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15174    | 0.15174    | 0.15174    |   0.0 |  0.06
Output  | 0.00018186 | 0.00018186 | 0.00018186 |   0.0 |  0.00
Modify  | 0.71995    | 0.71995    | 0.71995    |   0.0 |  0.26
Other   |            | 0.09778    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343818.0 ave      343818 max      343818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343818
Ave neighs/atom = 85.954500
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.250638779878, Press = -0.649479342398968
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13882.102   -13882.102    -14020.31    -14020.31    267.37358    267.37358    47887.043    47887.043   -453.24449   -453.24449 
   29000   -13875.991   -13875.991   -14017.667   -14017.667    274.08226    274.08226    47901.999    47901.999   -644.05548   -644.05548 
Loop time of 260.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.392 hours/ns, 3.837 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    | 259.7      | 259.7      | 259.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14564    | 0.14564    | 0.14564    |   0.0 |  0.06
Output  | 0.00018159 | 0.00018159 | 0.00018159 |   0.0 |  0.00
Modify  | 0.66638    | 0.66638    | 0.66638    |   0.0 |  0.26
Other   |            | 0.09326    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343704.0 ave      343704 max      343704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343704
Ave neighs/atom = 85.926000
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.283204890984, Press = 2.15409617895587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13875.991   -13875.991   -14017.667   -14017.667    274.08226    274.08226    47901.999    47901.999   -644.05548   -644.05548 
   30000   -13876.909   -13876.909   -14018.401   -14018.401     273.7262     273.7262    47848.159    47848.159    847.89668    847.89668 
Loop time of 260.64 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.400 hours/ns, 3.837 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    | 259.73     | 259.73     | 259.73     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14565    | 0.14565    | 0.14565    |   0.0 |  0.06
Output  | 0.00022424 | 0.00022424 | 0.00022424 |   0.0 |  0.00
Modify  | 0.6672     | 0.6672     | 0.6672     |   0.0 |  0.26
Other   |            | 0.09308    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343710.0 ave      343710 max      343710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343710
Ave neighs/atom = 85.927500
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.287638731585, Press = 1.65544015931042
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13876.909   -13876.909   -14018.401   -14018.401     273.7262     273.7262    47848.159    47848.159    847.89668    847.89668 
   31000   -13877.174   -13877.174   -14016.305   -14016.305    269.15847    269.15847    47860.423    47860.423    728.70937    728.70937 
Loop time of 260.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.452 hours/ns, 3.834 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    | 259.92     | 259.92     | 259.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14556    | 0.14556    | 0.14556    |   0.0 |  0.06
Output  | 0.0001764  | 0.0001764  | 0.0001764  |   0.0 |  0.00
Modify  | 0.66559    | 0.66559    | 0.66559    |   0.0 |  0.26
Other   |            | 0.09261    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343746.0 ave      343746 max      343746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343746
Ave neighs/atom = 85.936500
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.360836371833, Press = 0.673787333133185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13877.174   -13877.174   -14016.305   -14016.305    269.15847    269.15847    47860.423    47860.423    728.70937    728.70937 
   32000   -13874.625   -13874.625   -14014.849   -14014.849    271.27341    271.27341    47927.722    47927.722   -1099.8373   -1099.8373 
Loop time of 260.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.441 hours/ns, 3.835 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    | 259.88     | 259.88     | 259.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14567    | 0.14567    | 0.14567    |   0.0 |  0.06
Output  | 0.00018085 | 0.00018085 | 0.00018085 |   0.0 |  0.00
Modify  | 0.66664    | 0.66664    | 0.66664    |   0.0 |  0.26
Other   |            | 0.09328    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343720.0 ave      343720 max      343720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343720
Ave neighs/atom = 85.930000
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.365211913073, Press = -0.00443486122045832
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13874.625   -13874.625   -14014.849   -14014.849    271.27341    271.27341    47927.722    47927.722   -1099.8373   -1099.8373 
   33000   -13879.894   -13879.894    -14019.68    -14019.68    270.42677    270.42677    47889.594    47889.594   -445.07359   -445.07359 
Loop time of 260.607 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.391 hours/ns, 3.837 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    | 259.7      | 259.7      | 259.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14573    | 0.14573    | 0.14573    |   0.0 |  0.06
Output  | 0.0001811  | 0.0001811  | 0.0001811  |   0.0 |  0.00
Modify  | 0.66779    | 0.66779    | 0.66779    |   0.0 |  0.26
Other   |            | 0.0933     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343632.0 ave      343632 max      343632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343632
Ave neighs/atom = 85.908000
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.415206516952, Press = 2.80259131552242
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13879.894   -13879.894    -14019.68    -14019.68    270.42677    270.42677    47889.594    47889.594   -445.07359   -445.07359 
   34000   -13870.909   -13870.909   -14016.507   -14016.507    281.67029    281.67029    47856.914    47856.914    964.15896    964.15896 
Loop time of 300.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.288 ns/day, 83.446 hours/ns, 3.329 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    | 299.31     | 299.31     | 299.31     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16361    | 0.16361    | 0.16361    |   0.0 |  0.05
Output  | 0.00023042 | 0.00023042 | 0.00023042 |   0.0 |  0.00
Modify  | 0.83025    | 0.83025    | 0.83025    |   0.0 |  0.28
Other   |            | 0.1053     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343702.0 ave      343702 max      343702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343702
Ave neighs/atom = 85.925500
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.446132460843, Press = 1.26885279704028
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13870.909   -13870.909   -14016.507   -14016.507    281.67029    281.67029    47856.914    47856.914    964.15896    964.15896 
   35000   -13879.051   -13879.051   -14020.474   -14020.474    273.59279    273.59279    47861.114    47861.114    288.14979    288.14979 
Loop time of 301.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.286 ns/day, 83.783 hours/ns, 3.315 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    | 300.52     | 300.52     | 300.52     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16232    | 0.16232    | 0.16232    |   0.0 |  0.05
Output  | 0.00017747 | 0.00017747 | 0.00017747 |   0.0 |  0.00
Modify  | 0.82859    | 0.82859    | 0.82859    |   0.0 |  0.27
Other   |            | 0.1056     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343758.0 ave      343758 max      343758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343758
Ave neighs/atom = 85.939500
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.474769697197, Press = 0.304595115770726
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13879.051   -13879.051   -14020.474   -14020.474    273.59279    273.59279    47861.114    47861.114    288.14979    288.14979 
   36000    -13874.04    -13874.04    -14015.51    -14015.51    273.68492    273.68492    47921.491    47921.491   -1003.9953   -1003.9953 
Loop time of 298.584 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.289 ns/day, 82.940 hours/ns, 3.349 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    | 297.48     | 297.48     | 297.48     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16393    | 0.16393    | 0.16393    |   0.0 |  0.05
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.83257    | 0.83257    | 0.83257    |   0.0 |  0.28
Other   |            | 0.1062     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343750.0 ave      343750 max      343750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343750
Ave neighs/atom = 85.937500
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.509900816134, Press = 0.394929493535776
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -13874.04    -13874.04    -14015.51    -14015.51    273.68492    273.68492    47921.491    47921.491   -1003.9953   -1003.9953 
   37000   -13880.878   -13880.878   -14017.926   -14017.926    265.12889    265.12889    47897.776    47897.776    -658.5167    -658.5167 
Loop time of 302.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.164 hours/ns, 3.300 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    | 301.89     | 301.89     | 301.89     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1628     | 0.1628     | 0.1628     |   0.0 |  0.05
Output  | 0.00022912 | 0.00022912 | 0.00022912 |   0.0 |  0.00
Modify  | 0.83505    | 0.83505    | 0.83505    |   0.0 |  0.28
Other   |            | 0.1054     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343628.0 ave      343628 max      343628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343628
Ave neighs/atom = 85.907000
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.499676333379, Press = 2.75998008887162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13880.878   -13880.878   -14017.926   -14017.926    265.12889    265.12889    47897.776    47897.776    -658.5167    -658.5167 
   38000   -13876.585   -13876.585   -14019.885   -14019.885    277.22372    277.22372    47806.391    47806.391    1955.6254    1955.6254 
Loop time of 303.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.258 hours/ns, 3.297 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    | 302.21     | 302.21     | 302.21     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16392    | 0.16392    | 0.16392    |   0.0 |  0.05
Output  | 0.00024691 | 0.00024691 | 0.00024691 |   0.0 |  0.00
Modify  | 0.84421    | 0.84421    | 0.84421    |   0.0 |  0.28
Other   |            | 0.1062     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343758.0 ave      343758 max      343758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343758
Ave neighs/atom = 85.939500
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.456064513186, Press = 1.07808270238372
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13876.585   -13876.585   -14019.885   -14019.885    277.22372    277.22372    47806.391    47806.391    1955.6254    1955.6254 
   39000   -13878.876   -13878.876   -14019.633   -14019.633    272.30428    272.30428    47894.413    47894.413   -658.12503   -658.12503 
Loop time of 303.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.344 hours/ns, 3.293 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    | 302.52     | 302.52     | 302.52     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16416    | 0.16416    | 0.16416    |   0.0 |  0.05
Output  | 0.00017838 | 0.00017838 | 0.00017838 |   0.0 |  0.00
Modify  | 0.84673    | 0.84673    | 0.84673    |   0.0 |  0.28
Other   |            | 0.1066     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343766.0 ave      343766 max      343766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343766
Ave neighs/atom = 85.941500
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.450270067256, Press = 0.610505689027513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13878.876   -13878.876   -14019.633   -14019.633    272.30428    272.30428    47894.413    47894.413   -658.12503   -658.12503 
   40000   -13874.146   -13874.146   -14015.765   -14015.765    273.97109    273.97109    47894.254    47894.254   -177.95875   -177.95875 
Loop time of 301.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.695 hours/ns, 3.319 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    | 300.2      | 300.2      | 300.2      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16118    | 0.16118    | 0.16118    |   0.0 |  0.05
Output  | 0.00017862 | 0.00017862 | 0.00017862 |   0.0 |  0.00
Modify  | 0.8292     | 0.8292     | 0.8292     |   0.0 |  0.28
Other   |            | 0.1063     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343782.0 ave      343782 max      343782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343782
Ave neighs/atom = 85.945500
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.470378858146, Press = 1.46541427165007
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13874.146   -13874.146   -14015.765   -14015.765    273.97109    273.97109    47894.254    47894.254   -177.95875   -177.95875 
   41000   -13877.952   -13877.952   -14020.253   -14020.253    275.29242    275.29242    47820.661    47820.661    1415.6671    1415.6671 
Loop time of 304.53 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.592 hours/ns, 3.284 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    | 303.41     | 303.41     | 303.41     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16492    | 0.16492    | 0.16492    |   0.0 |  0.05
Output  | 0.00046869 | 0.00046869 | 0.00046869 |   0.0 |  0.00
Modify  | 0.84586    | 0.84586    | 0.84586    |   0.0 |  0.28
Other   |            | 0.1071     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343702.0 ave      343702 max      343702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343702
Ave neighs/atom = 85.925500
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.458252727031, Press = 1.2836629437546
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13877.952   -13877.952   -14020.253   -14020.253    275.29242    275.29242    47820.661    47820.661    1415.6671    1415.6671 
   42000   -13876.101   -13876.101   -14015.691   -14015.691     270.0477     270.0477    47876.966    47876.966    316.47061    316.47061 
Loop time of 304.489 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.580 hours/ns, 3.284 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    | 303.36     | 303.36     | 303.36     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16632    | 0.16632    | 0.16632    |   0.0 |  0.05
Output  | 0.00017921 | 0.00017921 | 0.00017921 |   0.0 |  0.00
Modify  | 0.85534    | 0.85534    | 0.85534    |   0.0 |  0.28
Other   |            | 0.1087     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343760.0 ave      343760 max      343760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343760
Ave neighs/atom = 85.940000
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.419385056646, Press = -1.46210791061916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13876.101   -13876.101   -14015.691   -14015.691     270.0477     270.0477    47876.966    47876.966    316.47061    316.47061 
   43000   -13879.491   -13879.491   -14016.603   -14016.603    265.25311    265.25311    47948.651    47948.651   -1867.2388   -1867.2388 
Loop time of 274.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.315 ns/day, 76.283 hours/ns, 3.641 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    | 273.65     | 273.65     | 273.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15004    | 0.15004    | 0.15004    |   0.0 |  0.05
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.72065    | 0.72065    | 0.72065    |   0.0 |  0.26
Other   |            | 0.09868    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343694.0 ave      343694 max      343694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343694
Ave neighs/atom = 85.923500
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.37340114559, Press = 1.49655091955055
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13879.491   -13879.491   -14016.603   -14016.603    265.25311    265.25311    47948.651    47948.651   -1867.2388   -1867.2388 
   44000   -13878.924   -13878.924   -14021.584   -14021.584    275.98568    275.98568    47846.831    47846.831    645.60607    645.60607 
Loop time of 300.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.288 ns/day, 83.471 hours/ns, 3.328 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    | 299.42     | 299.42     | 299.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16289    | 0.16289    | 0.16289    |   0.0 |  0.05
Output  | 0.00017689 | 0.00017689 | 0.00017689 |   0.0 |  0.00
Modify  | 0.80977    | 0.80977    | 0.80977    |   0.0 |  0.27
Other   |            | 0.1054     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343602.0 ave      343602 max      343602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343602
Ave neighs/atom = 85.900500
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.356434250103, Press = 1.54481517295033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13878.924   -13878.924   -14021.584   -14021.584    275.98568    275.98568    47846.831    47846.831    645.60607    645.60607 
   45000   -13875.002   -13875.002   -14018.803   -14018.803    278.19276    278.19276     47864.55     47864.55    396.73294    396.73294 
Loop time of 264.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.384 hours/ns, 3.785 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    | 263.26     | 263.26     | 263.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14518    | 0.14518    | 0.14518    |   0.0 |  0.05
Output  | 0.00017625 | 0.00017625 | 0.00017625 |   0.0 |  0.00
Modify  | 0.68316    | 0.68316    | 0.68316    |   0.0 |  0.26
Other   |            | 0.097      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343814.0 ave      343814 max      343814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343814
Ave neighs/atom = 85.953500
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.346729143254, Press = 0.532952104815816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13875.002   -13875.002   -14018.803   -14018.803    278.19276    278.19276     47864.55     47864.55    396.73294    396.73294 
   46000   -13880.848   -13880.848   -14021.512   -14021.512    272.12578    272.12578    47906.898    47906.898   -1214.6907   -1214.6907 
Loop time of 260.684 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.412 hours/ns, 3.836 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    | 259.78     | 259.78     | 259.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14444    | 0.14444    | 0.14444    |   0.0 |  0.06
Output  | 0.00022266 | 0.00022266 | 0.00022266 |   0.0 |  0.00
Modify  | 0.66553    | 0.66553    | 0.66553    |   0.0 |  0.26
Other   |            | 0.09477    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343722.0 ave      343722 max      343722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343722
Ave neighs/atom = 85.930500
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.359366828317, Press = 0.236497469753992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13880.848   -13880.848   -14021.512   -14021.512    272.12578    272.12578    47906.898    47906.898   -1214.6907   -1214.6907 
   47000   -13873.626   -13873.626   -14018.063   -14018.063    279.42207    279.42207    47904.694    47904.694   -592.91227   -592.91227 
Loop time of 260.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.339 hours/ns, 3.840 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    | 259.52     | 259.52     | 259.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.145      | 0.145      | 0.145      |   0.0 |  0.06
Output  | 0.00018627 | 0.00018627 | 0.00018627 |   0.0 |  0.00
Modify  | 0.66382    | 0.66382    | 0.66382    |   0.0 |  0.25
Other   |            | 0.09309    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343620.0 ave      343620 max      343620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343620
Ave neighs/atom = 85.905000
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.348713837916, Press = 1.57337621347441
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13873.626   -13873.626   -14018.063   -14018.063    279.42207    279.42207    47904.694    47904.694   -592.91227   -592.91227 
   48000   -13878.785   -13878.785   -14021.539   -14021.539    276.16787    276.16787    47805.041    47805.041    1829.3605    1829.3605 
Loop time of 275.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.313 ns/day, 76.629 hours/ns, 3.625 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    | 274.87     | 274.87     | 274.87     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15256    | 0.15256    | 0.15256    |   0.0 |  0.06
Output  | 0.00027766 | 0.00027766 | 0.00027766 |   0.0 |  0.00
Modify  | 0.73779    | 0.73779    | 0.73779    |   0.0 |  0.27
Other   |            | 0.0995     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343678.0 ave      343678 max      343678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343678
Ave neighs/atom = 85.919500
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.382044411952, Press = 1.2004798153529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13878.785   -13878.785   -14021.539   -14021.539    276.16787    276.16787    47805.041    47805.041    1829.3605    1829.3605 
   49000   -13872.221   -13872.221   -14014.822   -14014.822    275.87115    275.87115     47894.63     47894.63   -8.5558686   -8.5558686 
Loop time of 304.38 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.550 hours/ns, 3.285 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    | 303.27     | 303.27     | 303.27     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16614    | 0.16614    | 0.16614    |   0.0 |  0.05
Output  | 0.00024629 | 0.00024629 | 0.00024629 |   0.0 |  0.00
Modify  | 0.83894    | 0.83894    | 0.83894    |   0.0 |  0.28
Other   |            | 0.1065     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343714.0 ave      343714 max      343714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343714
Ave neighs/atom = 85.928500
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.403210292891, Press = -0.385507648155265
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13872.221   -13872.221   -14014.822   -14014.822    275.87115    275.87115     47894.63     47894.63   -8.5558686   -8.5558686 
   50000   -13877.123   -13877.123   -14018.122   -14018.122    272.77131    272.77131    47925.788    47925.788   -1268.3515   -1268.3515 
Loop time of 276.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.312 ns/day, 76.842 hours/ns, 3.615 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    | 275.65     | 275.65     | 275.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15022    | 0.15022    | 0.15022    |   0.0 |  0.05
Output  | 0.00022538 | 0.00022538 | 0.00022538 |   0.0 |  0.00
Modify  | 0.73065    | 0.73065    | 0.73065    |   0.0 |  0.26
Other   |            | 0.09971    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343658.0 ave      343658 max      343658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343658
Ave neighs/atom = 85.914500
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.409608821306, Press = 0.736562799514376
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13877.123   -13877.123   -14018.122   -14018.122    272.77131    272.77131    47925.788    47925.788   -1268.3515   -1268.3515 
   51000   -13879.054   -13879.054    -14021.35    -14021.35    275.28066    275.28066    47863.955    47863.955    116.56831    116.56831 
Loop time of 290.938 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.297 ns/day, 80.816 hours/ns, 3.437 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    | 289.88     | 289.88     | 289.88     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15726    | 0.15726    | 0.15726    |   0.0 |  0.05
Output  | 0.00024648 | 0.00024648 | 0.00024648 |   0.0 |  0.00
Modify  | 0.79295    | 0.79295    | 0.79295    |   0.0 |  0.27
Other   |            | 0.1045     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343612.0 ave      343612 max      343612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343612
Ave neighs/atom = 85.903000
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.410638951419, Press = 1.49972606794115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13879.054   -13879.054    -14021.35    -14021.35    275.28066    275.28066    47863.955    47863.955    116.56831    116.56831 
   52000   -13878.896   -13878.896   -14018.351   -14018.351    269.78445    269.78445    47832.774    47832.774    1308.8923    1308.8923 
Loop time of 303.239 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.233 hours/ns, 3.298 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    | 302.14     | 302.14     | 302.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16176    | 0.16176    | 0.16176    |   0.0 |  0.05
Output  | 0.00022921 | 0.00022921 | 0.00022921 |   0.0 |  0.00
Modify  | 0.83503    | 0.83503    | 0.83503    |   0.0 |  0.28
Other   |            | 0.1067     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343702.0 ave      343702 max      343702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343702
Ave neighs/atom = 85.925500
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.398679938879, Press = 0.527549492340182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13878.896   -13878.896   -14018.351   -14018.351    269.78445    269.78445    47832.774    47832.774    1308.8923    1308.8923 
   53000   -13875.734   -13875.734   -14016.523   -14016.523    272.36595    272.36595    47925.536    47925.536   -1083.6558   -1083.6558 
Loop time of 265.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.682 hours/ns, 3.770 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    | 264.33     | 264.33     | 264.33     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14231    | 0.14231    | 0.14231    |   0.0 |  0.05
Output  | 0.00017741 | 0.00017741 | 0.00017741 |   0.0 |  0.00
Modify  | 0.68676    | 0.68676    | 0.68676    |   0.0 |  0.26
Other   |            | 0.09686    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343760.0 ave      343760 max      343760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343760
Ave neighs/atom = 85.940000
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.410791651891, Press = 0.134157210449819
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13875.734   -13875.734   -14016.523   -14016.523    272.36595    272.36595    47925.536    47925.536   -1083.6558   -1083.6558 
   54000   -13878.118   -13878.118   -14017.419   -14017.419    269.48743    269.48743    47912.056    47912.056   -1025.4708   -1025.4708 
Loop time of 265.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.787 hours/ns, 3.765 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    | 264.71     | 264.71     | 264.71     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14526    | 0.14526    | 0.14526    |   0.0 |  0.05
Output  | 0.00017915 | 0.00017915 | 0.00017915 |   0.0 |  0.00
Modify  | 0.68471    | 0.68471    | 0.68471    |   0.0 |  0.26
Other   |            | 0.09563    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343632.0 ave      343632 max      343632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343632
Ave neighs/atom = 85.908000
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.405369138023, Press = 1.5536593539813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13878.118   -13878.118   -14017.419   -14017.419    269.48743    269.48743    47912.056    47912.056   -1025.4708   -1025.4708 
   55000   -13877.511   -13877.511   -14018.726   -14018.726    273.19115    273.19115     47852.18     47852.18    731.64675    731.64675 
Loop time of 263.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.248 hours/ns, 3.792 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    | 262.77     | 262.77     | 262.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14472    | 0.14472    | 0.14472    |   0.0 |  0.05
Output  | 0.00017602 | 0.00017602 | 0.00017602 |   0.0 |  0.00
Modify  | 0.67702    | 0.67702    | 0.67702    |   0.0 |  0.26
Other   |            | 0.09493    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343668.0 ave      343668 max      343668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343668
Ave neighs/atom = 85.917000
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.401632572814, Press = 0.663139882559101
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13877.511   -13877.511   -14018.726   -14018.726    273.19115    273.19115     47852.18     47852.18    731.64675    731.64675 
   56000     -13881.1     -13881.1   -14020.067   -14020.067    268.84131    268.84131    47869.998    47869.998   -89.837181   -89.837181 
Loop time of 269.315 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.321 ns/day, 74.810 hours/ns, 3.713 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    | 268.38     | 268.38     | 268.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14445    | 0.14445    | 0.14445    |   0.0 |  0.05
Output  | 0.00017836 | 0.00017836 | 0.00017836 |   0.0 |  0.00
Modify  | 0.69716    | 0.69716    | 0.69716    |   0.0 |  0.26
Other   |            | 0.09741    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343750.0 ave      343750 max      343750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343750
Ave neighs/atom = 85.937500
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.3995921303, Press = 0.469542667878909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000     -13881.1     -13881.1   -14020.067   -14020.067    268.84131    268.84131    47869.998    47869.998   -89.837181   -89.837181 
   57000   -13877.272   -13877.272   -14018.166   -14018.166    272.56966    272.56966    47892.379    47892.379   -405.30586   -405.30586 
Loop time of 303.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.363 hours/ns, 3.293 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    | 302.6      | 302.6      | 302.6      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16202    | 0.16202    | 0.16202    |   0.0 |  0.05
Output  | 0.00017842 | 0.00017842 | 0.00017842 |   0.0 |  0.00
Modify  | 0.8406     | 0.8406     | 0.8406     |   0.0 |  0.28
Other   |            | 0.1069     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343674.0 ave      343674 max      343674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343674
Ave neighs/atom = 85.918500
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.363608155004, Press = 0.412296899137389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13877.272   -13877.272   -14018.166   -14018.166    272.56966    272.56966    47892.379    47892.379   -405.30586   -405.30586 
   58000   -13878.508   -13878.508   -14020.098   -14020.098    273.91501    273.91501    47902.655    47902.655   -899.74419   -899.74419 
Loop time of 301.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.613 hours/ns, 3.322 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    | 299.88     | 299.88     | 299.88     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16398    | 0.16398    | 0.16398    |   0.0 |  0.05
Output  | 0.00022553 | 0.00022553 | 0.00022553 |   0.0 |  0.00
Modify  | 0.85078    | 0.85078    | 0.85078    |   0.0 |  0.28
Other   |            | 0.1082     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343692.0 ave      343692 max      343692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343692
Ave neighs/atom = 85.923000
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.361148892013, Press = 1.16261379760427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13878.508   -13878.508   -14020.098   -14020.098    273.91501    273.91501    47902.655    47902.655   -899.74419   -899.74419 
   59000   -13873.841   -13873.841   -14017.227   -14017.227    277.39008    277.39008    47824.505    47824.505    1749.0927    1749.0927 
Loop time of 281.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.307 ns/day, 78.159 hours/ns, 3.554 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    | 280.37     | 280.37     | 280.37     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15204    | 0.15204    | 0.15204    |   0.0 |  0.05
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.74605    | 0.74605    | 0.74605    |   0.0 |  0.27
Other   |            | 0.1015     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343674.0 ave      343674 max      343674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343674
Ave neighs/atom = 85.918500
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.376930676229, Press = 1.06774321336626
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13873.841   -13873.841   -14017.227   -14017.227    277.39008    277.39008    47824.505    47824.505    1749.0927    1749.0927 
   60000   -13880.178   -13880.178   -14021.614   -14021.614    273.61793    273.61793    47873.638    47873.638    -254.8189    -254.8189 
Loop time of 279.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.310 ns/day, 77.538 hours/ns, 3.582 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    | 278.15     | 278.15     | 278.15     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15015    | 0.15015    | 0.15015    |   0.0 |  0.05
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.73295    | 0.73295    | 0.73295    |   0.0 |  0.26
Other   |            | 0.1005     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343836.0 ave      343836 max      343836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343836
Ave neighs/atom = 85.959000
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.39314253524, Press = -0.179220653328437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13880.178   -13880.178   -14021.614   -14021.614    273.61793    273.61793    47873.638    47873.638    -254.8189    -254.8189 
   61000   -13872.327   -13872.327   -14017.965   -14017.965    281.74631    281.74631    47943.674    47943.674   -1728.4648   -1728.4648 
Loop time of 282.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.306 ns/day, 78.500 hours/ns, 3.539 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    | 281.59     | 281.59     | 281.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15483    | 0.15483    | 0.15483    |   0.0 |  0.05
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.75379    | 0.75379    | 0.75379    |   0.0 |  0.27
Other   |            | 0.102      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343748.0 ave      343748 max      343748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343748
Ave neighs/atom = 85.937000
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.412197739742, Press = 0.458280013222603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -13872.327   -13872.327   -14017.965   -14017.965    281.74631    281.74631    47943.674    47943.674   -1728.4648   -1728.4648 
   62000   -13879.277   -13879.277   -14019.988   -14019.988    272.21489    272.21489    47876.927    47876.927   -142.26816   -142.26816 
Loop time of 259.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.148 hours/ns, 3.850 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    | 258.83     | 258.83     | 258.83     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14134    | 0.14134    | 0.14134    |   0.0 |  0.05
Output  | 0.00017641 | 0.00017641 | 0.00017641 |   0.0 |  0.00
Modify  | 0.66382    | 0.66382    | 0.66382    |   0.0 |  0.26
Other   |            | 0.09521    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343600.0 ave      343600 max      343600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343600
Ave neighs/atom = 85.900000
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.41921564172, Press = 0.915153993883779
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13879.277   -13879.277   -14019.988   -14019.988    272.21489    272.21489    47876.927    47876.927   -142.26816   -142.26816 
   63000   -13875.875   -13875.875   -14019.638   -14019.638    278.11932    278.11932    47881.613    47881.613   -187.44736   -187.44736 
Loop time of 259.133 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 71.981 hours/ns, 3.859 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    | 258.24     | 258.24     | 258.24     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14112    | 0.14112    | 0.14112    |   0.0 |  0.05
Output  | 0.0001791  | 0.0001791  | 0.0001791  |   0.0 |  0.00
Modify  | 0.66037    | 0.66037    | 0.66037    |   0.0 |  0.25
Other   |            | 0.09496    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343750.0 ave      343750 max      343750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343750
Ave neighs/atom = 85.937500
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.398518656315, Press = 0.4490002455655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -13875.875   -13875.875   -14019.638   -14019.638    278.11932    278.11932    47881.613    47881.613   -187.44736   -187.44736 
   64000   -13878.087   -13878.087   -14019.915   -14019.915    274.37541    274.37541    47882.297    47882.297   -311.63586   -311.63586 
Loop time of 264.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.551 hours/ns, 3.777 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    | 263.86     | 263.86     | 263.86     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14392    | 0.14392    | 0.14392    |   0.0 |  0.05
Output  | 0.0002182  | 0.0002182  | 0.0002182  |   0.0 |  0.00
Modify  | 0.68429    | 0.68429    | 0.68429    |   0.0 |  0.26
Other   |            | 0.09622    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343768.0 ave      343768 max      343768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343768
Ave neighs/atom = 85.942000
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.376098151374, Press = 0.594465072134914
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -13878.087   -13878.087   -14019.915   -14019.915    274.37541    274.37541    47882.297    47882.297   -311.63586   -311.63586 
   65000   -13877.831   -13877.831   -14017.937   -14017.937    271.04473    271.04473    47863.059    47863.059    501.76911    501.76911 
Loop time of 305.718 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.283 ns/day, 84.922 hours/ns, 3.271 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 304.58     | 304.58     | 304.58     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16731    | 0.16731    | 0.16731    |   0.0 |  0.05
Output  | 0.00023003 | 0.00023003 | 0.00023003 |   0.0 |  0.00
Modify  | 0.86593    | 0.86593    | 0.86593    |   0.0 |  0.28
Other   |            | 0.1091     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343752.0 ave      343752 max      343752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343752
Ave neighs/atom = 85.938000
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.376253029444, Press = 0.55192703290948
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -13877.831   -13877.831   -14017.937   -14017.937    271.04473    271.04473    47863.059    47863.059    501.76911    501.76911 
   66000    -13876.91    -13876.91   -14018.256   -14018.256    273.44374    273.44374    47878.624    47878.624    54.869871    54.869871 
Loop time of 289.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.299 ns/day, 80.312 hours/ns, 3.459 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    | 288.07     | 288.07     | 288.07     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15843    | 0.15843    | 0.15843    |   0.0 |  0.05
Output  | 0.0001797  | 0.0001797  | 0.0001797  |   0.0 |  0.00
Modify  | 0.79202    | 0.79202    | 0.79202    |   0.0 |  0.27
Other   |            | 0.1038     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343640.0 ave      343640 max      343640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343640
Ave neighs/atom = 85.910000
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.372001806279, Press = 0.406866059617217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -13876.91    -13876.91   -14018.256   -14018.256    273.44374    273.44374    47878.624    47878.624    54.869871    54.869871 
   67000   -13878.988   -13878.988   -14021.416   -14021.416    275.53604    275.53604    47887.889    47887.889   -601.42707   -601.42707 
Loop time of 304.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.595 hours/ns, 3.284 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    | 303.43     | 303.43     | 303.43     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16315    | 0.16315    | 0.16315    |   0.0 |  0.05
Output  | 0.00054941 | 0.00054941 | 0.00054941 |   0.0 |  0.00
Modify  | 0.84618    | 0.84618    | 0.84618    |   0.0 |  0.28
Other   |            | 0.1067     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343700.0 ave      343700 max      343700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343700
Ave neighs/atom = 85.925000
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.404233456855, Press = 0.523039177472139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -13878.988   -13878.988   -14021.416   -14021.416    275.53604    275.53604    47887.889    47887.889   -601.42707   -601.42707 
   68000   -13876.475   -13876.475   -14018.627   -14018.627    275.00244    275.00244    47867.951    47867.951    267.12554    267.12554 
Loop time of 303.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.285 ns/day, 84.216 hours/ns, 3.298 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    | 302.07     | 302.07     | 302.07     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1618     | 0.1618     | 0.1618     |   0.0 |  0.05
Output  | 0.00018147 | 0.00018147 | 0.00018147 |   0.0 |  0.00
Modify  | 0.83796    | 0.83796    | 0.83796    |   0.0 |  0.28
Other   |            | 0.107      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343672.0 ave      343672 max      343672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343672
Ave neighs/atom = 85.918000
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.397630218502, Press = 0.491326667712605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -13876.475   -13876.475   -14018.627   -14018.627    275.00244    275.00244    47867.951    47867.951    267.12554    267.12554 
   69000   -13878.747   -13878.747   -14021.761   -14021.761    276.67083    276.67083    47891.682    47891.682   -839.77922   -839.77922 
Loop time of 304.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.454 hours/ns, 3.289 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    | 302.92     | 302.92     | 302.92     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16265    | 0.16265    | 0.16265    |   0.0 |  0.05
Output  | 0.00022651 | 0.00022651 | 0.00022651 |   0.0 |  0.00
Modify  | 0.84253    | 0.84253    | 0.84253    |   0.0 |  0.28
Other   |            | 0.107      |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343762.0 ave      343762 max      343762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343762
Ave neighs/atom = 85.940500
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.367093871994, Press = 0.0921381836780344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -13878.747   -13878.747   -14021.761   -14021.761    276.67083    276.67083    47891.682    47891.682   -839.77922   -839.77922 
   70000   -13875.754   -13875.754   -14019.681   -14019.681    278.43703    278.43703    47922.094    47922.094   -1399.5763   -1399.5763 
Loop time of 312.178 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.277 ns/day, 86.716 hours/ns, 3.203 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    | 311.03     | 311.03     | 311.03     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17154    | 0.17154    | 0.17154    |   0.0 |  0.05
Output  | 0.00019082 | 0.00019082 | 0.00019082 |   0.0 |  0.00
Modify  | 0.86852    | 0.86852    | 0.86852    |   0.0 |  0.28
Other   |            | 0.1084     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343672.0 ave      343672 max      343672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343672
Ave neighs/atom = 85.918000
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.342601234133, Press = 0.733800150337427
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -13875.754   -13875.754   -14019.681   -14019.681    278.43703    278.43703    47922.094    47922.094   -1399.5763   -1399.5763 
   71000   -13875.778   -13875.778   -14018.589   -14018.589    276.27816    276.27816    47836.806    47836.806    1177.1867    1177.1867 
Loop time of 297.801 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.290 ns/day, 82.723 hours/ns, 3.358 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 296.73     | 296.73     | 296.73     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16299    | 0.16299    | 0.16299    |   0.0 |  0.05
Output  | 0.0002488  | 0.0002488  | 0.0002488  |   0.0 |  0.00
Modify  | 0.80588    | 0.80588    | 0.80588    |   0.0 |  0.27
Other   |            | 0.1051     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343684.0 ave      343684 max      343684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343684
Ave neighs/atom = 85.921000
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.326546306946, Press = 1.0601625187105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -13875.778   -13875.778   -14018.589   -14018.589    276.27816    276.27816    47836.806    47836.806    1177.1867    1177.1867 
   72000   -13877.522   -13877.522   -14019.786   -14019.786    275.21876    275.21876    47838.826    47838.826      1015.46      1015.46 
Loop time of 271.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.318 ns/day, 75.524 hours/ns, 3.678 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    | 270.93     | 270.93     | 270.93     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1493     | 0.1493     | 0.1493     |   0.0 |  0.05
Output  | 0.00022292 | 0.00022292 | 0.00022292 |   0.0 |  0.00
Modify  | 0.71051    | 0.71051    | 0.71051    |   0.0 |  0.26
Other   |            | 0.09748    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      343798.0 ave      343798 max      343798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 343798
Ave neighs/atom = 85.949500
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.7307830317

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0