# 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.6133156493306164*${_u_distance}
variable latticeconst_converted equal 3.6133156493306164*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564933062
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.005 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_KangSaLee_2009_ZrAgCu__MO_813575892799_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.6297173106    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6297173106/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6297173106/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 47175.6297173106/(1*1*${_u_distance})
variable      V0_metal equal 47175.6297173106/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 47175.6297173106*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6297173106 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_813575892799_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.63     47175.63     3196.821     3196.821 
    1000   -13870.076   -13870.076   -14014.445   -14014.445    279.29183    279.29183    47934.911    47934.911   -1401.2822   -1401.2822 
Loop time of 359.919 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.977 hours/ns, 2.778 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    | 359.02     | 359.02     | 359.02     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14964    | 0.14964    | 0.14964    |   0.0 |  0.04
Output  | 0.0002251  | 0.0002251  | 0.0002251  |   0.0 |  0.00
Modify  | 0.65846    | 0.65846    | 0.65846    |   0.0 |  0.18
Other   |            | 0.09521    |            |       |  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:      536000.0 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.2822   -1401.2822 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069   -480.35121   -480.35121 
Loop time of 390.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.360 hours/ns, 2.563 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    | 389.13     | 389.13     | 389.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15715    | 0.15715    | 0.15715    |   0.0 |  0.04
Output  | 0.0002183  | 0.0002183  | 0.0002183  |   0.0 |  0.00
Modify  | 0.70839    | 0.70839    | 0.70839    |   0.0 |  0.18
Other   |            | 0.09881    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      530540.0 ave      530540 max      530540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530540
Ave neighs/atom = 132.63500
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13879.752   -13879.752   -14022.361   -14022.361    275.88555    275.88555    47875.069    47875.069   -480.35121   -480.35121 
    3000   -13877.049   -13877.049   -14021.487   -14021.487    279.42415    279.42415    47890.152    47890.152   -639.83313   -639.83313 
Loop time of 372.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.385 hours/ns, 2.687 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    | 371.27     | 371.27     | 371.27     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15143    | 0.15143    | 0.15143    |   0.0 |  0.04
Output  | 0.00025731 | 0.00025731 | 0.00025731 |   0.0 |  0.00
Modify  | 0.66293    | 0.66293    | 0.66293    |   0.0 |  0.18
Other   |            | 0.09572    |            |       |  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:      531896.0 ave      531896 max      531896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531896
Ave neighs/atom = 132.97400
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.83313   -639.83313 
    4000    -13877.12    -13877.12   -14018.007   -14018.007    272.55582    272.55582    47905.817    47905.817   -856.44913   -856.44913 
Loop time of 364.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.129 hours/ns, 2.747 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    | 363.18     | 363.18     | 363.18     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14865    | 0.14865    | 0.14865    |   0.0 |  0.04
Output  | 0.00021846 | 0.00021846 | 0.00021846 |   0.0 |  0.00
Modify  | 0.64056    | 0.64056    | 0.64056    |   0.0 |  0.18
Other   |            | 0.09314    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531992.0 ave      531992 max      531992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531992
Ave neighs/atom = 132.99800
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.44913   -856.44913 
    5000    -13880.22    -13880.22   -14017.363   -14017.363    265.31181    265.31181    47860.951    47860.951    513.55638    513.55638 
Loop time of 404.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.284 hours/ns, 2.474 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    | 403.22     | 403.22     | 403.22     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15941    | 0.15941    | 0.15941    |   0.0 |  0.04
Output  | 0.0001785  | 0.0001785  | 0.0001785  |   0.0 |  0.00
Modify  | 0.74349    | 0.74349    | 0.74349    |   0.0 |  0.18
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531344.0 ave      531344 max      531344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531344
Ave neighs/atom = 132.83600
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.452430988879, Press = 727.423261100719
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.31181    265.31181    47860.951    47860.951    513.55638    513.55638 
    6000   -13874.143   -13874.143   -14020.344   -14020.344    282.83644    282.83644    47823.358    47823.358    1491.2034    1491.2034 
Loop time of 400.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.286 hours/ns, 2.496 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    | 399.61     | 399.61     | 399.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15923    | 0.15923    | 0.15923    |   0.0 |  0.04
Output  | 0.00018038 | 0.00018038 | 0.00018038 |   0.0 |  0.00
Modify  | 0.75951    | 0.75951    | 0.75951    |   0.0 |  0.19
Other   |            | 0.1005     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5847.00 ave        5847 max        5847 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:      531754.0 ave      531754 max      531754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531754
Ave neighs/atom = 132.93850
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.610071930302, Press = 17.7903659552992
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.2034    1491.2034 
    7000   -13880.514   -13880.514   -14019.502   -14019.502    268.88252    268.88252    47908.507    47908.507   -1036.1862   -1036.1862 
Loop time of 374.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.991 hours/ns, 2.671 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    | 373.43     | 373.43     | 373.43     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15115    | 0.15115    | 0.15115    |   0.0 |  0.04
Output  | 0.0001806  | 0.0001806  | 0.0001806  |   0.0 |  0.00
Modify  | 0.69268    | 0.69268    | 0.69268    |   0.0 |  0.19
Other   |            | 0.09511    |            |       |  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:      532250.0 ave      532250 max      532250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532250
Ave neighs/atom = 133.06250
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.0121144884, Press = -4.48328202074888
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.1862   -1036.1862 
    8000    -13879.31    -13879.31    -14018.24    -14018.24    268.76918    268.76918    47900.154    47900.154   -711.71958   -711.71958 
Loop time of 427.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.707 hours/ns, 2.340 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    | 426.24     | 426.24     | 426.24     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16755    | 0.16755    | 0.16755    |   0.0 |  0.04
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.82538    | 0.82538    | 0.82538    |   0.0 |  0.19
Other   |            | 0.1055     |            |       |  0.02

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:      531768.0 ave      531768 max      531768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531768
Ave neighs/atom = 132.94200
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.088072688226, Press = 19.9536975900456
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.71958   -711.71958 
    9000   -13873.264   -13873.264   -14014.598   -14014.598    273.41891    273.41891     47847.43     47847.43    1351.3954    1351.3954 
Loop time of 427.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.656 hours/ns, 2.341 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    | 426.06     | 426.06     | 426.06     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16795    | 0.16795    | 0.16795    |   0.0 |  0.04
Output  | 0.00022154 | 0.00022154 | 0.00022154 |   0.0 |  0.00
Modify  | 0.82734    | 0.82734    | 0.82734    |   0.0 |  0.19
Other   |            | 0.1076     |            |       |  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:      531408.0 ave      531408 max      531408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531408
Ave neighs/atom = 132.85200
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.383464329876, Press = 12.2281066533576
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.3954    1351.3954 
   10000   -13875.848   -13875.848   -14016.169   -14016.169    271.46094    271.46094    47872.004    47872.004    394.42789    394.42789 
Loop time of 428.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.904 hours/ns, 2.336 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    | 426.95     | 426.95     | 426.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16795    | 0.16795    | 0.16795    |   0.0 |  0.04
Output  | 0.0002758  | 0.0002758  | 0.0002758  |   0.0 |  0.00
Modify  | 0.82958    | 0.82958    | 0.82958    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      531758.0 ave      531758 max      531758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531758
Ave neighs/atom = 132.93950
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.298218951416, Press = 4.1125820404626
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.46094    271.46094    47872.004    47872.004    394.42789    394.42789 
   11000    -13880.74    -13880.74     -14018.7     -14018.7    266.89318    266.89318    47903.178    47903.178   -896.70159   -896.70159 
Loop time of 427.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.734 hours/ns, 2.340 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    | 426.34     | 426.34     | 426.34     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16762    | 0.16762    | 0.16762    |   0.0 |  0.04
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.82792    | 0.82792    | 0.82792    |   0.0 |  0.19
Other   |            | 0.1075     |            |       |  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:      531570.0 ave      531570 max      531570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531570
Ave neighs/atom = 132.89250
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.181711248316, Press = 2.01455277653718
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.70159   -896.70159 
   12000   -13879.029   -13879.029   -14019.863   -14019.863     272.4539     272.4539    47887.829    47887.829   -429.56146   -429.56146 
Loop time of 397.276 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.355 hours/ns, 2.517 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    | 396.26     | 396.26     | 396.26     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15966    | 0.15966    | 0.15966    |   0.0 |  0.04
Output  | 0.00017868 | 0.00017868 | 0.00017868 |   0.0 |  0.00
Modify  | 0.75194    | 0.75194    | 0.75194    |   0.0 |  0.19
Other   |            | 0.1002     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531558.0 ave      531558 max      531558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531558
Ave neighs/atom = 132.88950
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.921835114044, Press = 11.4619202794839
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.4539     272.4539    47887.829    47887.829   -429.56146   -429.56146 
   13000   -13879.086   -13879.086    -14020.59    -14020.59    273.74982    273.74982    47798.836    47798.836    2059.7515    2059.7515 
Loop time of 400.137 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.149 hours/ns, 2.499 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    | 399.12     | 399.12     | 399.12     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15983    | 0.15983    | 0.15983    |   0.0 |  0.04
Output  | 0.00023135 | 0.00023135 | 0.00023135 |   0.0 |  0.00
Modify  | 0.75254    | 0.75254    | 0.75254    |   0.0 |  0.19
Other   |            | 0.1009     |            |       |  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:      531802.0 ave      531802 max      531802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531802
Ave neighs/atom = 132.95050
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.939817005842, Press = 2.55585632935541
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 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.7515    2059.7515 
   14000   -13872.139   -13872.139   -14013.705   -14013.705    273.86901    273.86901    47913.934    47913.934    -537.4531    -537.4531 
Loop time of 429.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.324 hours/ns, 2.328 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    | 428.45     | 428.45     | 428.45     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16899    | 0.16899    | 0.16899    |   0.0 |  0.04
Output  | 0.00018016 | 0.00018016 | 0.00018016 |   0.0 |  0.00
Modify  | 0.83519    | 0.83519    | 0.83519    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532336.0 ave      532336 max      532336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532336
Ave neighs/atom = 133.08400
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.053853924731, Press = 0.995174333398772
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13872.139   -13872.139   -14013.705   -14013.705    273.86901    273.86901    47913.934    47913.934    -537.4531    -537.4531 
   15000   -13879.089   -13879.089   -14019.724   -14019.724    272.06775    272.06775    47872.854    47872.854   -92.950777   -92.950777 
Loop time of 422.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.236 hours/ns, 2.369 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    | 420.97     | 420.97     | 420.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16542    | 0.16542    | 0.16542    |   0.0 |  0.04
Output  | 0.00022721 | 0.00022721 | 0.00022721 |   0.0 |  0.00
Modify  | 0.81086    | 0.81086    | 0.81086    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.02

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:      531258.0 ave      531258 max      531258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531258
Ave neighs/atom = 132.81450
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.187709062327, Press = 3.89263003441673
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13879.089   -13879.089   -14019.724   -14019.724    272.06775    272.06775    47872.854    47872.854   -92.950777   -92.950777 
   16000   -13882.528   -13882.528   -14022.503   -14022.503    270.79034    270.79034    47843.467    47843.467    497.13278    497.13278 
Loop time of 428.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 119.022 hours/ns, 2.334 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    | 427.37     | 427.37     | 427.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1674     | 0.1674     | 0.1674     |   0.0 |  0.04
Output  | 0.00017885 | 0.00017885 | 0.00017885 |   0.0 |  0.00
Modify  | 0.83378    | 0.83378    | 0.83378    |   0.0 |  0.19
Other   |            | 0.1073     |            |       |  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:      531674.0 ave      531674 max      531674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531674
Ave neighs/atom = 132.91850
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.15921576263, Press = 3.819703519853
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13882.528   -13882.528   -14022.503   -14022.503    270.79034    270.79034    47843.467    47843.467    497.13278    497.13278 
   17000   -13874.867   -13874.867   -14016.188   -14016.188    273.39427    273.39427     47860.69     47860.69    750.31141    750.31141 
Loop time of 384.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.924 hours/ns, 2.598 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    | 383.95     | 383.95     | 383.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1545     | 0.1545     | 0.1545     |   0.0 |  0.04
Output  | 0.00018188 | 0.00018188 | 0.00018188 |   0.0 |  0.00
Modify  | 0.7221     | 0.7221     | 0.7221     |   0.0 |  0.19
Other   |            | 0.0998     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532044.0 ave      532044 max      532044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532044
Ave neighs/atom = 133.01100
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.066202334935, Press = 1.51870610316941
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13874.867   -13874.867   -14016.188   -14016.188    273.39427    273.39427     47860.69     47860.69    750.31141    750.31141 
   18000    -13878.81    -13878.81   -14019.492   -14019.492    272.15869    272.15869    47904.386    47904.386   -991.15901   -991.15901 
Loop time of 421.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.043 hours/ns, 2.373 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    | 420.26     | 420.26     | 420.26     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16584    | 0.16584    | 0.16584    |   0.0 |  0.04
Output  | 0.00017935 | 0.00017935 | 0.00017935 |   0.0 |  0.00
Modify  | 0.82085    | 0.82085    | 0.82085    |   0.0 |  0.19
Other   |            | 0.1057     |            |       |  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:      531554.0 ave      531554 max      531554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531554
Ave neighs/atom = 132.88850
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.204850460819, Press = 0.325162978598218
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -13878.81    -13878.81   -14019.492   -14019.492    272.15869    272.15869    47904.386    47904.386   -991.15901   -991.15901 
   19000    -13872.72    -13872.72   -14012.955   -14012.955    271.29532    271.29532    47911.961    47911.961   -450.02679   -450.02679 
Loop time of 408.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.353 hours/ns, 2.451 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    | 407.02     | 407.02     | 407.02     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16285    | 0.16285    | 0.16285    |   0.0 |  0.04
Output  | 0.0001797  | 0.0001797  | 0.0001797  |   0.0 |  0.00
Modify  | 0.78777    | 0.78777    | 0.78777    |   0.0 |  0.19
Other   |            | 0.1041     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531640.0 ave      531640 max      531640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531640
Ave neighs/atom = 132.91000
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.269261529104, Press = 4.25922467696243
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13872.72    -13872.72   -14012.955   -14012.955    271.29532    271.29532    47911.961    47911.961   -450.02679   -450.02679 
   20000   -13879.982   -13879.982   -14021.678   -14021.678    274.12128    274.12128    47799.831    47799.831    1864.1979    1864.1979 
Loop time of 370.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.874 hours/ns, 2.700 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    | 369.41     | 369.41     | 369.41     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15023    | 0.15023    | 0.15023    |   0.0 |  0.04
Output  | 0.00017881 | 0.00017881 | 0.00017881 |   0.0 |  0.00
Modify  | 0.68602    | 0.68602    | 0.68602    |   0.0 |  0.19
Other   |            | 0.09633    |            |       |  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:      530964.0 ave      530964 max      530964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 530964
Ave neighs/atom = 132.74100
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.319549809831, Press = 2.33974774278399
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13879.982   -13879.982   -14021.678   -14021.678    274.12128    274.12128    47799.831    47799.831    1864.1979    1864.1979 
   21000   -13877.003   -13877.003    -14019.34    -14019.34    275.36042    275.36042    47891.125    47891.125   -392.52963   -392.52963 
Loop time of 419.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.645 hours/ns, 2.381 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    | 418.85     | 418.85     | 418.85     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16453    | 0.16453    | 0.16453    |   0.0 |  0.04
Output  | 0.00018169 | 0.00018169 | 0.00018169 |   0.0 |  0.00
Modify  | 0.80885    | 0.80885    | 0.80885    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      532356.0 ave      532356 max      532356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532356
Ave neighs/atom = 133.08900
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.260856725513, Press = -1.96452991264579
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13877.003   -13877.003    -14019.34    -14019.34    275.36042    275.36042    47891.125    47891.125   -392.52963   -392.52963 
   22000   -13880.465   -13880.465   -14019.797   -14019.797    269.54756    269.54756      47924.8      47924.8   -1613.7083   -1613.7083 
Loop time of 427.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.861 hours/ns, 2.337 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    | 426.8      | 426.8      | 426.8      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1673     | 0.1673     | 0.1673     |   0.0 |  0.04
Output  | 0.00023287 | 0.00023287 | 0.00023287 |   0.0 |  0.00
Modify  | 0.82764    | 0.82764    | 0.82764    |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531688.0 ave      531688 max      531688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531688
Ave neighs/atom = 132.92200
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.239011353857, Press = 3.04431295743859
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13880.465   -13880.465   -14019.797   -14019.797    269.54756    269.54756      47924.8      47924.8   -1613.7083   -1613.7083 
   23000   -13878.934   -13878.934   -14017.408   -14017.408    267.88839    267.88839    47845.336    47845.336    1015.4627    1015.4627 
Loop time of 415.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.324 hours/ns, 2.409 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    | 414.1      | 414.1      | 414.1      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16437    | 0.16437    | 0.16437    |   0.0 |  0.04
Output  | 0.00018612 | 0.00018612 | 0.00018612 |   0.0 |  0.00
Modify  | 0.79755    | 0.79755    | 0.79755    |   0.0 |  0.19
Other   |            | 0.1043     |            |       |  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:      531570.0 ave      531570 max      531570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531570
Ave neighs/atom = 132.89250
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.260730976126, Press = 2.6915566705017
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13878.934   -13878.934   -14017.408   -14017.408    267.88839    267.88839    47845.336    47845.336    1015.4627    1015.4627 
   24000    -13874.98    -13874.98   -14018.224   -14018.224    277.11578    277.11578    47867.732    47867.732    390.53569    390.53569 
Loop time of 404.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.332 hours/ns, 2.473 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    | 403.36     | 403.36     | 403.36     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16185    | 0.16185    | 0.16185    |   0.0 |  0.04
Output  | 0.00022893 | 0.00022893 | 0.00022893 |   0.0 |  0.00
Modify  | 0.77354    | 0.77354    | 0.77354    |   0.0 |  0.19
Other   |            | 0.1022     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531922.0 ave      531922 max      531922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531922
Ave neighs/atom = 132.98050
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.246216783946, Press = 0.79972368516867
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -13874.98    -13874.98   -14018.224   -14018.224    277.11578    277.11578    47867.732    47867.732    390.53569    390.53569 
   25000   -13882.174   -13882.174   -14018.832   -14018.832    264.37439    264.37439    47900.992    47900.992   -788.68006   -788.68006 
Loop time of 394.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.636 hours/ns, 2.534 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    | 393.69     | 393.69     | 393.69     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15797    | 0.15797    | 0.15797    |   0.0 |  0.04
Output  | 0.00022915 | 0.00022915 | 0.00022915 |   0.0 |  0.00
Modify  | 0.74574    | 0.74574    | 0.74574    |   0.0 |  0.19
Other   |            | 0.09928    |            |       |  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:      531830.0 ave      531830 max      531830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531830
Ave neighs/atom = 132.95750
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.200393844709, Press = 0.639205232314355
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13882.174   -13882.174   -14018.832   -14018.832    264.37439    264.37439    47900.992    47900.992   -788.68006   -788.68006 
   26000   -13877.006   -13877.006   -14016.951   -14016.951    270.73362    270.73362    47891.837    47891.837   -182.24939   -182.24939 
Loop time of 364.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.355 hours/ns, 2.741 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    | 363.96     | 363.96     | 363.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1509     | 0.1509     | 0.1509     |   0.0 |  0.04
Output  | 0.00018116 | 0.00018116 | 0.00018116 |   0.0 |  0.00
Modify  | 0.66857    | 0.66857    | 0.66857    |   0.0 |  0.18
Other   |            | 0.09325    |            |       |  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:      531706.0 ave      531706 max      531706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531706
Ave neighs/atom = 132.92650
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.138107019489, Press = 4.76830629995961
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13877.006   -13877.006   -14016.951   -14016.951    270.73362    270.73362    47891.837    47891.837   -182.24939   -182.24939 
   27000   -13882.515   -13882.515   -14019.049   -14019.049    264.13576    264.13576    47770.688    47770.688     2917.511     2917.511 
Loop time of 365.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.409 hours/ns, 2.739 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    | 364.16     | 364.16     | 364.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15126    | 0.15126    | 0.15126    |   0.0 |  0.04
Output  | 0.00023024 | 0.00023024 | 0.00023024 |   0.0 |  0.00
Modify  | 0.67118    | 0.67118    | 0.67118    |   0.0 |  0.18
Other   |            | 0.09343    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531940.0 ave      531940 max      531940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531940
Ave neighs/atom = 132.98500
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.113056883228, Press = 1.33578041127257
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13882.515   -13882.515   -14019.049   -14019.049    264.13576    264.13576    47770.688    47770.688     2917.511     2917.511 
   28000   -13877.963   -13877.963   -14018.162   -14018.162    271.22616    271.22616    47897.665    47897.665   -471.46854   -471.46854 
Loop time of 389.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.214 hours/ns, 2.567 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    | 388.58     | 388.58     | 388.58     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15655    | 0.15655    | 0.15655    |   0.0 |  0.04
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.73172    | 0.73172    | 0.73172    |   0.0 |  0.19
Other   |            | 0.0996     |            |       |  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:      532314.0 ave      532314 max      532314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532314
Ave neighs/atom = 133.07850
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.017656703647, Press = -0.313273787822651
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13877.963   -13877.963   -14018.162   -14018.162    271.22616    271.22616    47897.665    47897.665   -471.46854   -471.46854 
   29000   -13880.802   -13880.802   -14019.745   -14019.745    268.79461    268.79461    47895.213    47895.213   -755.73389   -755.73389 
Loop time of 364.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.314 hours/ns, 2.742 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    | 363.82     | 363.82     | 363.82     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1506     | 0.1506     | 0.1506     |   0.0 |  0.04
Output  | 0.00018001 | 0.00018001 | 0.00018001 |   0.0 |  0.00
Modify  | 0.66877    | 0.66877    | 0.66877    |   0.0 |  0.18
Other   |            | 0.09365    |            |       |  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:      531840.0 ave      531840 max      531840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531840
Ave neighs/atom = 132.96000
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.986633565668, Press = 2.24577573303464
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13880.802   -13880.802   -14019.745   -14019.745    268.79461    268.79461    47895.213    47895.213   -755.73389   -755.73389 
   30000   -13875.256   -13875.256   -14017.649   -14017.649    275.46883    275.46883     47843.41     47843.41    1079.0384    1079.0384 
Loop time of 365.098 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.416 hours/ns, 2.739 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    | 364.19     | 364.19     | 364.19     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14843    | 0.14843    | 0.14843    |   0.0 |  0.04
Output  | 0.00022705 | 0.00022705 | 0.00022705 |   0.0 |  0.00
Modify  | 0.66604    | 0.66604    | 0.66604    |   0.0 |  0.18
Other   |            | 0.09289    |            |       |  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:      531680.0 ave      531680 max      531680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531680
Ave neighs/atom = 132.92000
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.925838829429, Press = 1.85043035279786
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13875.256   -13875.256   -14017.649   -14017.649    275.46883    275.46883     47843.41     47843.41    1079.0384    1079.0384 
   31000    -13880.31    -13880.31   -14018.099   -14018.099    266.56373    266.56373    47844.564    47844.564    954.77601    954.77601 
Loop time of 365.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.532 hours/ns, 2.736 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    | 364.61     | 364.61     | 364.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14682    | 0.14682    | 0.14682    |   0.0 |  0.04
Output  | 0.00018273 | 0.00018273 | 0.00018273 |   0.0 |  0.00
Modify  | 0.66669    | 0.66669    | 0.66669    |   0.0 |  0.18
Other   |            | 0.09265    |            |       |  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:      532100.0 ave      532100 max      532100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532100
Ave neighs/atom = 133.02500
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.900906671342, Press = 0.642523991929101
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -13880.31    -13880.31   -14018.099   -14018.099    266.56373    266.56373    47844.564    47844.564    954.77601    954.77601 
   32000   -13879.102   -13879.102   -14016.797   -14016.797    266.37891    266.37891    47938.583    47938.583    -1688.148    -1688.148 
Loop time of 365.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.596 hours/ns, 2.734 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    | 364.84     | 364.84     | 364.84     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14761    | 0.14761    | 0.14761    |   0.0 |  0.04
Output  | 0.0001811  | 0.0001811  | 0.0001811  |   0.0 |  0.00
Modify  | 0.66724    | 0.66724    | 0.66724    |   0.0 |  0.18
Other   |            | 0.09332    |            |       |  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:      531842.0 ave      531842 max      531842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531842
Ave neighs/atom = 132.96050
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.920650067885, Press = -0.363463983694276
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13879.102   -13879.102   -14016.797   -14016.797    266.37891    266.37891    47938.583    47938.583    -1688.148    -1688.148 
   33000    -13878.48    -13878.48    -14019.27    -14019.27    272.36655    272.36655    47896.078    47896.078   -566.71491   -566.71491 
Loop time of 412.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.451 hours/ns, 2.427 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    | 410.97     | 410.97     | 410.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16106    | 0.16106    | 0.16106    |   0.0 |  0.04
Output  | 0.00017855 | 0.00017855 | 0.00017855 |   0.0 |  0.00
Modify  | 0.78458    | 0.78458    | 0.78458    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531340.0 ave      531340 max      531340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531340
Ave neighs/atom = 132.83500
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.969929514368, Press = 3.07970739178206
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -13878.48    -13878.48    -14019.27    -14019.27    272.36655    272.36655    47896.078    47896.078   -566.71491   -566.71491 
   34000    -13881.58    -13881.58   -14022.441   -14022.441    272.50529    272.50529    47826.151    47826.151    1073.4404    1073.4404 
Loop time of 428.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 119.028 hours/ns, 2.334 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    | 427.39     | 427.39     | 427.39     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16645    | 0.16645    | 0.16645    |   0.0 |  0.04
Output  | 0.00028373 | 0.00028373 | 0.00028373 |   0.0 |  0.00
Modify  | 0.83491    | 0.83491    | 0.83491    |   0.0 |  0.19
Other   |            | 0.1075     |            |       |  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:      531854.0 ave      531854 max      531854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531854
Ave neighs/atom = 132.96350
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.994618196302, Press = 1.75414630564569
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -13881.58    -13881.58   -14022.441   -14022.441    272.50529    272.50529    47826.151    47826.151    1073.4404    1073.4404 
   35000   -13876.544   -13876.544   -14019.166   -14019.166    275.91308    275.91308    47851.525    47851.525     734.7495     734.7495 
Loop time of 405.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.690 hours/ns, 2.465 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    | 404.65     | 404.65     | 404.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15914    | 0.15914    | 0.15914    |   0.0 |  0.04
Output  | 0.00017826 | 0.00017826 | 0.00017826 |   0.0 |  0.00
Modify  | 0.77661    | 0.77661    | 0.77661    |   0.0 |  0.19
Other   |            | 0.1022     |            |       |  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:      532346.0 ave      532346 max      532346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532346
Ave neighs/atom = 133.08650
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.939314370912, Press = 0.525815151248554
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13876.544   -13876.544   -14019.166   -14019.166    275.91308    275.91308    47851.525    47851.525     734.7495     734.7495 
   36000    -13880.45    -13880.45    -14018.91    -14018.91    267.86017    267.86017    47893.541    47893.541   -641.70464   -641.70464 
Loop time of 384.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.925 hours/ns, 2.598 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    | 383.96     | 383.96     | 383.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15461    | 0.15461    | 0.15461    |   0.0 |  0.04
Output  | 0.0001796  | 0.0001796  | 0.0001796  |   0.0 |  0.00
Modify  | 0.7188     | 0.7188     | 0.7188     |   0.0 |  0.19
Other   |            | 0.09745    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      531768.0 ave      531768 max      531768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531768
Ave neighs/atom = 132.94200
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.944387206744, Press = 0.666382278925987
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -13880.45    -13880.45    -14018.91    -14018.91    267.86017    267.86017    47893.541    47893.541   -641.70464   -641.70464 
   37000   -13874.189   -13874.189   -14014.531   -14014.531    271.50174    271.50174    47888.734    47888.734    80.001602    80.001602 
Loop time of 421.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.014 hours/ns, 2.374 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    | 420.17     | 420.17     | 420.17     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16469    | 0.16469    | 0.16469    |   0.0 |  0.04
Output  | 0.00017737 | 0.00017737 | 0.00017737 |   0.0 |  0.00
Modify  | 0.80982    | 0.80982    | 0.80982    |   0.0 |  0.19
Other   |            | 0.1045     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5843.00 ave        5843 max        5843 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:      531484.0 ave      531484 max      531484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531484
Ave neighs/atom = 132.87100
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.998810419668, Press = 1.51783046421584
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13874.189   -13874.189   -14014.531   -14014.531    271.50174    271.50174    47888.734    47888.734    80.001602    80.001602 
   38000   -13879.813   -13879.813   -14020.437   -14020.437    272.04756    272.04756    47846.661    47846.661    704.17035    704.17035 
Loop time of 414.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.252 hours/ns, 2.410 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    | 413.85     | 413.85     | 413.85     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16226    | 0.16226    | 0.16226    |   0.0 |  0.04
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.79427    | 0.79427    | 0.79427    |   0.0 |  0.19
Other   |            | 0.1044     |            |       |  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:      531098.0 ave      531098 max      531098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531098
Ave neighs/atom = 132.77450
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.006024122081, Press = 0.695082512703822
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13879.813   -13879.813   -14020.437   -14020.437    272.04756    272.04756    47846.661    47846.661    704.17035    704.17035 
   39000   -13876.427   -13876.427   -14019.109   -14019.109    276.02741    276.02741    47915.455    47915.455   -1190.6958   -1190.6958 
Loop time of 418.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.381 hours/ns, 2.387 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    | 417.9      | 417.9      | 417.9      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16253    | 0.16253    | 0.16253    |   0.0 |  0.04
Output  | 0.00017722 | 0.00017722 | 0.00017722 |   0.0 |  0.00
Modify  | 0.80304    | 0.80304    | 0.80304    |   0.0 |  0.19
Other   |            | 0.105      |            |       |  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:      532126.0 ave      532126 max      532126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532126
Ave neighs/atom = 133.03150
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.005041453667, Press = 0.986588658495138
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13876.427   -13876.427   -14019.109   -14019.109    276.02741    276.02741    47915.455    47915.455   -1190.6958   -1190.6958 
   40000   -13880.262   -13880.262   -14019.893   -14019.893     270.1264     270.1264    47840.902    47840.902    856.05777    856.05777 
Loop time of 380.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.719 hours/ns, 2.628 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    | 379.63     | 379.63     | 379.63     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15134    | 0.15134    | 0.15134    |   0.0 |  0.04
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.70656    | 0.70656    | 0.70656    |   0.0 |  0.19
Other   |            | 0.09775    |            |       |  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:      531380.0 ave      531380 max      531380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531380
Ave neighs/atom = 132.84500
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.955396651039, Press = 3.01294694273456
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13880.262   -13880.262   -14019.893   -14019.893     270.1264     270.1264    47840.902    47840.902    856.05777    856.05777 
   41000   -13877.034   -13877.034   -14019.735   -14019.735    276.06543    276.06543    47805.285    47805.285    1990.0118    1990.0118 
Loop time of 425.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.157 hours/ns, 2.351 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    | 424.27     | 424.27     | 424.27     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16486    | 0.16486    | 0.16486    |   0.0 |  0.04
Output  | 0.00023734 | 0.00023734 | 0.00023734 |   0.0 |  0.00
Modify  | 0.82226    | 0.82226    | 0.82226    |   0.0 |  0.19
Other   |            | 0.1054     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5845.00 ave        5845 max        5845 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:      531902.0 ave      531902 max      531902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531902
Ave neighs/atom = 132.97550
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.932651369964, Press = 0.236326739857977
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13877.034   -13877.034   -14019.735   -14019.735    276.06543    276.06543    47805.285    47805.285    1990.0118    1990.0118 
   42000   -13877.461   -13877.461   -14017.717   -14017.717    271.33525    271.33525    47907.742    47907.742   -877.33003   -877.33003 
Loop time of 416.625 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.729 hours/ns, 2.400 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    | 415.56     | 415.56     | 415.56     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16306    | 0.16306    | 0.16306    |   0.0 |  0.04
Output  | 0.00017529 | 0.00017529 | 0.00017529 |   0.0 |  0.00
Modify  | 0.79682    | 0.79682    | 0.79682    |   0.0 |  0.19
Other   |            | 0.1042     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5842.00 ave        5842 max        5842 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:      532040.0 ave      532040 max      532040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532040
Ave neighs/atom = 133.01000
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.891200429699, Press = 0.0367095295016166
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13877.461   -13877.461   -14017.717   -14017.717    271.33525    271.33525    47907.742    47907.742   -877.33003   -877.33003 
   43000   -13880.498   -13880.498   -14018.667   -14018.667    267.29731    267.29731    47917.331    47917.331   -1259.0118   -1259.0118 
Loop time of 424.021 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.784 hours/ns, 2.358 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    | 422.93     | 422.93     | 422.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16535    | 0.16535    | 0.16535    |   0.0 |  0.04
Output  | 0.00023142 | 0.00023142 | 0.00023142 |   0.0 |  0.00
Modify  | 0.8226     | 0.8226     | 0.8226     |   0.0 |  0.19
Other   |            | 0.1052     |            |       |  0.02

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:      531464.0 ave      531464 max      531464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531464
Ave neighs/atom = 132.86600
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.900226665947, Press = 1.76250685096799
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13880.498   -13880.498   -14018.667   -14018.667    267.29731    267.29731    47917.331    47917.331   -1259.0118   -1259.0118 
   44000   -13872.892   -13872.892   -14015.631   -14015.631    276.13768    276.13768    47848.665    47848.665    1161.3752    1161.3752 
Loop time of 426.519 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.478 hours/ns, 2.345 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    | 425.42     | 425.42     | 425.42     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16544    | 0.16544    | 0.16544    |   0.0 |  0.04
Output  | 0.00017939 | 0.00017939 | 0.00017939 |   0.0 |  0.00
Modify  | 0.82912    | 0.82912    | 0.82912    |   0.0 |  0.19
Other   |            | 0.1052     |            |       |  0.02

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:      531606.0 ave      531606 max      531606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531606
Ave neighs/atom = 132.90150
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.911728142341, Press = 1.124742704446
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13872.892   -13872.892   -14015.631   -14015.631    276.13768    276.13768    47848.665    47848.665    1161.3752    1161.3752 
   45000   -13878.294   -13878.294   -14018.915   -14018.915      272.041      272.041    47869.282    47869.282    198.16127    198.16127 
Loop time of 403.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.034 hours/ns, 2.479 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    | 402.29     | 402.29     | 402.29     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15825    | 0.15825    | 0.15825    |   0.0 |  0.04
Output  | 0.00017993 | 0.00017993 | 0.00017993 |   0.0 |  0.00
Modify  | 0.77076    | 0.77076    | 0.77076    |   0.0 |  0.19
Other   |            | 0.1015     |            |       |  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:      531802.0 ave      531802 max      531802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531802
Ave neighs/atom = 132.95050
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.951830460401, Press = 0.334480571223997
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13878.294   -13878.294   -14018.915   -14018.915      272.041      272.041    47869.282    47869.282    198.16127    198.16127 
   46000    -13876.43    -13876.43   -14018.044   -14018.044    273.96202    273.96202    47899.997    47899.997   -570.35763   -570.35763 
Loop time of 421.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.171 hours/ns, 2.371 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    | 420.74     | 420.74     | 420.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16247    | 0.16247    | 0.16247    |   0.0 |  0.04
Output  | 0.00029236 | 0.00029236 | 0.00029236 |   0.0 |  0.00
Modify  | 0.80571    | 0.80571    | 0.80571    |   0.0 |  0.19
Other   |            | 0.1043     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5845.00 ave        5845 max        5845 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:      531834.0 ave      531834 max      531834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531834
Ave neighs/atom = 132.95850
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.9693043405, Press = 0.695991203742911
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -13876.43    -13876.43   -14018.044   -14018.044    273.96202    273.96202    47899.997    47899.997   -570.35763   -570.35763 
   47000   -13880.628   -13880.628   -14020.653   -14020.653    270.88888    270.88888    47857.738    47857.738    296.44298    296.44298 
Loop time of 428.629 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 119.064 hours/ns, 2.333 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    | 427.53     | 427.53     | 427.53     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16618    | 0.16618    | 0.16618    |   0.0 |  0.04
Output  | 0.00017893 | 0.00017893 | 0.00017893 |   0.0 |  0.00
Modify  | 0.82665    | 0.82665    | 0.82665    |   0.0 |  0.19
Other   |            | 0.1063     |            |       |  0.02

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:      531460.0 ave      531460 max      531460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 531460
Ave neighs/atom = 132.86500
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.95814720205, Press = 1.3762822457281
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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13880.628   -13880.628   -14020.653   -14020.653    270.88888    270.88888    47857.738    47857.738    296.44298    296.44298 
   48000   -13875.593   -13875.593   -14017.496   -14017.496    274.52129    274.52129    47824.969    47824.969    1614.7442    1614.7442 
Loop time of 422.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.403 hours/ns, 2.366 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    | 421.56     | 421.56     | 421.56     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16587    | 0.16587    | 0.16587    |   0.0 |  0.04
Output  | 0.00022917 | 0.00022917 | 0.00022917 |   0.0 |  0.00
Modify  | 0.8239     | 0.8239     | 0.8239     |   0.0 |  0.19
Other   |            | 0.1048     |            |       |  0.02

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:      532066.0 ave      532066 max      532066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532066
Ave neighs/atom = 133.01650
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
47875.6062319807

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0