# 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.003 seconds

variable mass_converted equal 63.546*${_u_mass}
variable mass_converted equal 63.546*1

kim_interactions Cu

WARNING: 'kim_<command>' has been renamed to 'kim <command>'. Please update your input.

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_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 253.15*${_u_temperature}
variable temp_converted equal 253.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -14029.144   -14029.144       -14160       -14160       253.15       253.15     47175.63     47175.63    2962.7501    2962.7501 
    1000   -13891.154   -13891.154   -14025.485   -14025.485    259.87077    259.87077    47819.315    47819.315     442.3156     442.3156 
Loop time of 410.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.957 hours/ns, 2.438 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    | 409.16     | 409.16     | 409.16     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16858    | 0.16858    | 0.16858    |   0.0 |  0.04
Output  | 0.00028212 | 0.00028212 | 0.00028212 |   0.0 |  0.00
Modify  | 0.81226    | 0.81226    | 0.81226    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  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   -13891.154   -13891.154   -14025.485   -14025.485    259.87077    259.87077    47819.315    47819.315     442.3156     442.3156 
    2000   -13900.169   -13900.169   -14032.673   -14032.673    256.33861    256.33861    47811.972    47811.972   -61.728881   -61.728881 
Loop time of 425.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.264 hours/ns, 2.349 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    | 424.68     | 424.68     | 424.68     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16546    | 0.16546    | 0.16546    |   0.0 |  0.04
Output  | 0.00022044 | 0.00022044 | 0.00022044 |   0.0 |  0.00
Modify  | 0.80058    | 0.80058    | 0.80058    |   0.0 |  0.19
Other   |            | 0.1056     |            |       |  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:      532064.0 ave      532064 max      532064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532064
Ave neighs/atom = 133.01600
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   -13900.169   -13900.169   -14032.673   -14032.673    256.33861    256.33861    47811.972    47811.972   -61.728881   -61.728881 
    3000   -13897.662   -13897.662   -14031.622   -14031.622    259.15446    259.15446    47835.404    47835.404   -463.39851   -463.39851 
Loop time of 391.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.784 hours/ns, 2.553 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    | 390.65     | 390.65     | 390.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15615    | 0.15615    | 0.15615    |   0.0 |  0.04
Output  | 0.00021785 | 0.00021785 | 0.00021785 |   0.0 |  0.00
Modify  | 0.71308    | 0.71308    | 0.71308    |   0.0 |  0.18
Other   |            | 0.09832    |            |       |  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:      532862.0 ave      532862 max      532862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532862
Ave neighs/atom = 133.21550
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   -13897.662   -13897.662   -14031.622   -14031.622    259.15446    259.15446    47835.404    47835.404   -463.39851   -463.39851 
    4000   -13897.892   -13897.892   -14028.238   -14028.238    252.16278    252.16278     47854.41     47854.41   -787.92399   -787.92399 
Loop time of 361.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.406 hours/ns, 2.767 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    | 360.58     | 360.58     | 360.58     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14716    | 0.14716    | 0.14716    |   0.0 |  0.04
Output  | 0.00021827 | 0.00021827 | 0.00021827 |   0.0 |  0.00
Modify  | 0.64083    | 0.64083    | 0.64083    |   0.0 |  0.18
Other   |            | 0.09257    |            |       |  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:      532924.0 ave      532924 max      532924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532924
Ave neighs/atom = 133.23100
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   -13897.892   -13897.892   -14028.238   -14028.238    252.16278    252.16278     47854.41     47854.41   -787.92399   -787.92399 
    5000   -13900.495   -13900.495   -14027.377   -14027.377    245.46266    245.46266    47857.258    47857.258   -765.09378   -765.09378 
Loop time of 410.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.144 hours/ns, 2.434 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    | 409.88     | 409.88     | 409.88     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16091    | 0.16091    | 0.16091    |   0.0 |  0.04
Output  | 0.00027983 | 0.00027983 | 0.00027983 |   0.0 |  0.00
Modify  | 0.77179    | 0.77179    | 0.77179    |   0.0 |  0.19
Other   |            | 0.1031     |            |       |  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:      532398.0 ave      532398 max      532398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532398
Ave neighs/atom = 133.09950
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 = 254.404965165748, Press = -50.0287466020804
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   -13900.495   -13900.495   -14027.377   -14027.377    245.46266    245.46266    47857.258    47857.258   -765.09378   -765.09378 
    6000   -13895.302   -13895.302    -14030.37    -14030.37    261.29721    261.29721    47874.139    47874.139   -1380.0529   -1380.0529 
Loop time of 425.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.085 hours/ns, 2.352 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 424        | 424        | 424        |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16657    | 0.16657    | 0.16657    |   0.0 |  0.04
Output  | 0.00018191 | 0.00018191 | 0.00018191 |   0.0 |  0.00
Modify  | 0.83495    | 0.83495    | 0.83495    |   0.0 |  0.20
Other   |            | 0.1053     |            |       |  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:      532454.0 ave      532454 max      532454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532454
Ave neighs/atom = 133.11350
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 = 252.675427070248, Press = 10.9561141383179
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   -13895.302   -13895.302    -14030.37    -14030.37    261.29721    261.29721    47874.139    47874.139   -1380.0529   -1380.0529 
    7000   -13900.818   -13900.818   -14030.162   -14030.162     250.2252     250.2252    47860.016    47860.016   -1100.7328   -1100.7328 
Loop time of 425.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.209 hours/ns, 2.350 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.45     | 424.45     | 424.45     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16554    | 0.16554    | 0.16554    |   0.0 |  0.04
Output  | 0.00022802 | 0.00022802 | 0.00022802 |   0.0 |  0.00
Modify  | 0.82901    | 0.82901    | 0.82901    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  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:      532652.0 ave      532652 max      532652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532652
Ave neighs/atom = 133.16300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.062926488011, Press = 8.16223637292265
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   -13900.818   -13900.818   -14030.162   -14030.162     250.2252     250.2252    47860.016    47860.016   -1100.7328   -1100.7328 
    8000   -13899.619   -13899.619   -14028.371   -14028.371    249.08023    249.08023    47857.003    47857.003   -844.14084   -844.14084 
Loop time of 413.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.837 hours/ns, 2.419 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    | 412.35     | 412.35     | 412.35     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16246    | 0.16246    | 0.16246    |   0.0 |  0.04
Output  | 0.00021911 | 0.00021911 | 0.00021911 |   0.0 |  0.00
Modify  | 0.8012     | 0.8012     | 0.8012     |   0.0 |  0.19
Other   |            | 0.103      |            |       |  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:      532694.0 ave      532694 max      532694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532694
Ave neighs/atom = 133.17350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.076891911548, Press = 9.71576461800801
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   -13899.619   -13899.619   -14028.371   -14028.371    249.08023    249.08023    47857.003    47857.003   -844.14084   -844.14084 
    9000   -13894.193   -13894.193   -14025.313   -14025.313    253.66063    253.66063    47851.931    47851.931   -210.61647   -210.61647 
Loop time of 381.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.021 hours/ns, 2.620 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    | 380.71     | 380.71     | 380.71     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15453    | 0.15453    | 0.15453    |   0.0 |  0.04
Output  | 0.00022761 | 0.00022761 | 0.00022761 |   0.0 |  0.00
Modify  | 0.71754    | 0.71754    | 0.71754    |   0.0 |  0.19
Other   |            | 0.09703    |            |       |  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:      532378.0 ave      532378 max      532378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532378
Ave neighs/atom = 133.09450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342494053432, Press = 8.70240011762556
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   -13894.193   -13894.193   -14025.313   -14025.313    253.66063    253.66063    47851.931    47851.931   -210.61647   -210.61647 
   10000   -13896.962   -13896.962    -14026.68    -14026.68    250.94912    250.94912     47840.66     47840.66   -155.94295   -155.94295 
Loop time of 417.822 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.062 hours/ns, 2.393 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    | 416.75     | 416.75     | 416.75     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1648     | 0.1648     | 0.1648     |   0.0 |  0.04
Output  | 0.00018096 | 0.00018096 | 0.00018096 |   0.0 |  0.00
Modify  | 0.80588    | 0.80588    | 0.80588    |   0.0 |  0.19
Other   |            | 0.1047     |            |       |  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:      532384.0 ave      532384 max      532384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532384
Ave neighs/atom = 133.09600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.253097098303, Press = 8.98707821829037
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   -13896.962   -13896.962    -14026.68    -14026.68    250.94912    250.94912     47840.66     47840.66   -155.94295   -155.94295 
   11000    -13900.07    -13900.07   -14029.121   -14029.121    249.65843    249.65843    47811.119    47811.119    347.91379    347.91379 
Loop time of 409.168 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.658 hours/ns, 2.444 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    | 408.11     | 408.11     | 408.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16231    | 0.16231    | 0.16231    |   0.0 |  0.04
Output  | 0.00018008 | 0.00018008 | 0.00018008 |   0.0 |  0.00
Modify  | 0.79365    | 0.79365    | 0.79365    |   0.0 |  0.19
Other   |            | 0.1038     |            |       |  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:      532554.0 ave      532554 max      532554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532554
Ave neighs/atom = 133.13850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.05030153928, Press = 3.79463225901026
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    -13900.07    -13900.07   -14029.121   -14029.121    249.65843    249.65843    47811.119    47811.119    347.91379    347.91379 
   12000   -13894.356   -13894.356   -14027.856   -14027.856     258.2654     258.2654    47817.166    47817.166    554.51106    554.51106 
Loop time of 423.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.754 hours/ns, 2.359 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    | 422.81     | 422.81     | 422.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16496    | 0.16496    | 0.16496    |   0.0 |  0.04
Output  | 0.00018166 | 0.00018166 | 0.00018166 |   0.0 |  0.00
Modify  | 0.83145    | 0.83145    | 0.83145    |   0.0 |  0.20
Other   |            | 0.1056     |            |       |  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:      532636.0 ave      532636 max      532636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532636
Ave neighs/atom = 133.15900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.121102597752, Press = 2.24809315813806
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   -13894.356   -13894.356   -14027.856   -14027.856     258.2654     258.2654    47817.166    47817.166    554.51106    554.51106 
   13000   -13899.103   -13899.103   -14029.904   -14029.904     253.0436     253.0436    47778.236    47778.236    1272.8443    1272.8443 
Loop time of 425.356 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.154 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.26     | 424.26     | 424.26     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16525    | 0.16525    | 0.16525    |   0.0 |  0.04
Output  | 0.00028062 | 0.00028062 | 0.00028062 |   0.0 |  0.00
Modify  | 0.82744    | 0.82744    | 0.82744    |   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:        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:      532654.0 ave      532654 max      532654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532654
Ave neighs/atom = 133.16350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.199251957458, Press = 1.40313198496131
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   -13899.103   -13899.103   -14029.904   -14029.904     253.0436     253.0436    47778.236    47778.236    1272.8443    1272.8443 
   14000   -13897.676   -13897.676   -14027.659   -14027.659     251.4599     251.4599    47769.823    47769.823    1708.4653    1708.4653 
Loop time of 398.462 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.684 hours/ns, 2.510 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    | 397.44     | 397.44     | 397.44     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15801    | 0.15801    | 0.15801    |   0.0 |  0.04
Output  | 0.00022894 | 0.00022894 | 0.00022894 |   0.0 |  0.00
Modify  | 0.75841    | 0.75841    | 0.75841    |   0.0 |  0.19
Other   |            | 0.1016     |            |       |  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:      533086.0 ave      533086 max      533086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533086
Ave neighs/atom = 133.27150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.407326204854, Press = -0.955467637161262
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   -13897.676   -13897.676   -14027.659   -14027.659     251.4599     251.4599    47769.823    47769.823    1708.4653    1708.4653 
   15000   -13898.713   -13898.713    -14029.58    -14029.58    253.17185    253.17185    47774.271    47774.271      1493.14      1493.14 
Loop time of 424.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.032 hours/ns, 2.353 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    | 423.81     | 423.81     | 423.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16694    | 0.16694    | 0.16694    |   0.0 |  0.04
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.83019    | 0.83019    | 0.83019    |   0.0 |  0.20
Other   |            | 0.1057     |            |       |  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:      532704.0 ave      532704 max      532704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532704
Ave neighs/atom = 133.17600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.362236118532, Press = -1.73348041449867
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   -13898.713   -13898.713    -14029.58    -14029.58    253.17185    253.17185    47774.271    47774.271      1493.14      1493.14 
   16000   -13897.926   -13897.926    -14029.16    -14029.16    253.88066    253.88066    47801.406    47801.406    713.04192    713.04192 
Loop time of 424.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.011 hours/ns, 2.354 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    | 423.73     | 423.73     | 423.73     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16655    | 0.16655    | 0.16655    |   0.0 |  0.04
Output  | 0.0002207  | 0.0002207  | 0.0002207  |   0.0 |  0.00
Modify  | 0.8325     | 0.8325     | 0.8325     |   0.0 |  0.20
Other   |            | 0.1065     |            |       |  0.03

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

Total # of neighbors = 532858
Ave neighs/atom = 133.21450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.356537644893, Press = -2.66181534318892
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   -13897.926   -13897.926    -14029.16    -14029.16    253.88066    253.88066    47801.406    47801.406    713.04192    713.04192 
   17000   -13900.905   -13900.905   -14028.278   -14028.278    246.41214    246.41214    47820.986    47820.986    208.56058    208.56058 
Loop time of 425.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.170 hours/ns, 2.351 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 424.31     | 424.31     | 424.31     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16622    | 0.16622    | 0.16622    |   0.0 |  0.04
Output  | 0.00018206 | 0.00018206 | 0.00018206 |   0.0 |  0.00
Modify  | 0.83389    | 0.83389    | 0.83389    |   0.0 |  0.20
Other   |            | 0.1064     |            |       |  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:      532774.0 ave      532774 max      532774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532774
Ave neighs/atom = 133.19350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.345360712897, Press = -1.47049134007214
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   -13900.905   -13900.905   -14028.278   -14028.278    246.41214    246.41214    47820.986    47820.986    208.56058    208.56058 
   18000   -13898.525   -13898.525   -14028.901   -14028.901    252.22079    252.22079    47834.483    47834.483   -220.85075   -220.85075 
Loop time of 424.601 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 117.945 hours/ns, 2.355 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    | 423.5      | 423.5      | 423.5      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16659    | 0.16659    | 0.16659    |   0.0 |  0.04
Output  | 0.00021742 | 0.00021742 | 0.00021742 |   0.0 |  0.00
Modify  | 0.82596    | 0.82596    | 0.82596    |   0.0 |  0.19
Other   |            | 0.1053     |            |       |  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:      532624.0 ave      532624 max      532624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532624
Ave neighs/atom = 133.15600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.36164560373, Press = -0.460910218963073
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   -13898.525   -13898.525   -14028.901   -14028.901    252.22079    252.22079    47834.483    47834.483   -220.85075   -220.85075 
   19000   -13898.241   -13898.241   -14026.376   -14026.376    247.88524    247.88524    47828.067    47828.067    200.77588    200.77588 
Loop time of 404.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.297 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.23     | 403.23     | 403.23     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15934    | 0.15934    | 0.15934    |   0.0 |  0.04
Output  | 0.00017847 | 0.00017847 | 0.00017847 |   0.0 |  0.00
Modify  | 0.77761    | 0.77761    | 0.77761    |   0.0 |  0.19
Other   |            | 0.102      |            |       |  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:      532546.0 ave      532546 max      532546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532546
Ave neighs/atom = 133.13650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.306227658883, Press = 0.681611320736985
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   -13898.241   -13898.241   -14026.376   -14026.376    247.88524    247.88524    47828.067    47828.067    200.77588    200.77588 
   20000   -13899.255   -13899.255   -14028.713   -14028.713    250.44609    250.44609    47834.572    47834.572   -219.87724   -219.87724 
Loop time of 361.636 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.454 hours/ns, 2.765 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 360.73     | 360.73     | 360.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14819    | 0.14819    | 0.14819    |   0.0 |  0.04
Output  | 0.00017785 | 0.00017785 | 0.00017785 |   0.0 |  0.00
Modify  | 0.66696    | 0.66696    | 0.66696    |   0.0 |  0.18
Other   |            | 0.09268    |            |       |  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:      532526.0 ave      532526 max      532526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532526
Ave neighs/atom = 133.13150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.309094889992, Press = 0.535540537663807
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   -13899.255   -13899.255   -14028.713   -14028.713    250.44609    250.44609    47834.572    47834.572   -219.87724   -219.87724 
   21000   -13892.727   -13892.727   -14025.367   -14025.367    256.60037    256.60037    47831.586    47831.586    356.48152    356.48152 
Loop time of 362.436 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.677 hours/ns, 2.759 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    | 361.53     | 361.53     | 361.53     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14909    | 0.14909    | 0.14909    |   0.0 |  0.04
Output  | 0.00017874 | 0.00017874 | 0.00017874 |   0.0 |  0.00
Modify  | 0.66791    | 0.66791    | 0.66791    |   0.0 |  0.18
Other   |            | 0.09347    |            |       |  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:      532744.0 ave      532744 max      532744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532744
Ave neighs/atom = 133.18600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.359084033195, Press = 1.8225722377032
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   -13892.727   -13892.727   -14025.367   -14025.367    256.60037    256.60037    47831.586    47831.586    356.48152    356.48152 
   22000   -13898.897   -13898.897   -14029.914   -14029.914     253.4607     253.4607     47790.77     47790.77    953.14094    953.14094 
Loop time of 383.977 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.660 hours/ns, 2.604 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    | 382.99     | 382.99     | 382.99     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15476    | 0.15476    | 0.15476    |   0.0 |  0.04
Output  | 0.00017965 | 0.00017965 | 0.00017965 |   0.0 |  0.00
Modify  | 0.72924    | 0.72924    | 0.72924    |   0.0 |  0.19
Other   |            | 0.09802    |            |       |  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:      532444.0 ave      532444 max      532444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532444
Ave neighs/atom = 133.11100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.451318332674, Press = 1.98356211063192
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   -13898.897   -13898.897   -14029.914   -14029.914     253.4607     253.4607     47790.77     47790.77    953.14094    953.14094 
   23000   -13895.849   -13895.849   -14028.219   -14028.219      256.079      256.079    47786.553    47786.553    1266.5595    1266.5595 
Loop time of 392.008 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.891 hours/ns, 2.551 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    | 391.01     | 391.01     | 391.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15648    | 0.15648    | 0.15648    |   0.0 |  0.04
Output  | 0.00018101 | 0.00018101 | 0.00018101 |   0.0 |  0.00
Modify  | 0.74479    | 0.74479    | 0.74479    |   0.0 |  0.19
Other   |            | 0.09952    |            |       |  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:      532758.0 ave      532758 max      532758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532758
Ave neighs/atom = 133.18950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.462876340101, Press = 1.58499912277641
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   -13895.849   -13895.849   -14028.219   -14028.219      256.079      256.079    47786.553    47786.553    1266.5595    1266.5595 
   24000   -13898.452   -13898.452   -14031.085   -14031.085    256.58772    256.58772    47792.721    47792.721    750.08484    750.08484 
Loop time of 426.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.466 hours/ns, 2.345 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.37     | 425.37     | 425.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16745    | 0.16745    | 0.16745    |   0.0 |  0.04
Output  | 0.00022307 | 0.00022307 | 0.00022307 |   0.0 |  0.00
Modify  | 0.83358    | 0.83358    | 0.83358    |   0.0 |  0.20
Other   |            | 0.1058     |            |       |  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:      532622.0 ave      532622 max      532622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532622
Ave neighs/atom = 133.15550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.551610337027, Press = 0.371805949760177
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   -13898.452   -13898.452   -14031.085   -14031.085    256.58772    256.58772    47792.721    47792.721    750.08484    750.08484 
   25000   -13894.322   -13894.322   -14026.626   -14026.626    255.95023    255.95023    47809.976    47809.976    868.40139    868.40139 
Loop time of 370.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.833 hours/ns, 2.701 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.27     | 369.27     | 369.27     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15138    | 0.15138    | 0.15138    |   0.0 |  0.04
Output  | 0.00021741 | 0.00021741 | 0.00021741 |   0.0 |  0.00
Modify  | 0.6878     | 0.6878     | 0.6878     |   0.0 |  0.19
Other   |            | 0.09523    |            |       |  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:      532836.0 ave      532836 max      532836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532836
Ave neighs/atom = 133.20900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.546296979978, Press = -0.339741233372481
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   -13894.322   -13894.322   -14026.626   -14026.626    255.95023    255.95023    47809.976    47809.976    868.40139    868.40139 
   26000   -13897.832   -13897.832   -14028.918   -14028.918    253.59468    253.59468    47815.121    47815.121    258.06584    258.06584 
Loop time of 362.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.689 hours/ns, 2.759 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    | 361.56     | 361.56     | 361.56     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.04
Output  | 0.00023079 | 0.00023079 | 0.00023079 |   0.0 |  0.00
Modify  | 0.67179    | 0.67179    | 0.67179    |   0.0 |  0.19
Other   |            | 0.09266    |            |       |  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:      532742.0 ave      532742 max      532742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532742
Ave neighs/atom = 133.18550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.534410692495, Press = -0.983307673638018
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   -13897.832   -13897.832   -14028.918   -14028.918    253.59468    253.59468    47815.121    47815.121    258.06584    258.06584 
   27000   -13898.781   -13898.781   -14030.471   -14030.471    254.76337    254.76337    47819.634    47819.634    41.989126    41.989126 
Loop time of 383.49 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.525 hours/ns, 2.608 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    | 382.51     | 382.51     | 382.51     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15639    | 0.15639    | 0.15639    |   0.0 |  0.04
Output  | 0.00028076 | 0.00028076 | 0.00028076 |   0.0 |  0.00
Modify  | 0.72504    | 0.72504    | 0.72504    |   0.0 |  0.19
Other   |            | 0.0974     |            |       |  0.03

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:      532740.0 ave      532740 max      532740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532740
Ave neighs/atom = 133.18500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.433937138946, Press = -0.337886933146397
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   -13898.781   -13898.781   -14030.471   -14030.471    254.76337    254.76337    47819.634    47819.634    41.989126    41.989126 
   28000   -13898.426   -13898.426   -14028.185   -14028.185    251.02727    251.02727    47825.655    47825.655    116.88555    116.88555 
Loop time of 408.659 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.516 hours/ns, 2.447 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.61     | 407.61     | 407.61     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16077    | 0.16077    | 0.16077    |   0.0 |  0.04
Output  | 0.0001858  | 0.0001858  | 0.0001858  |   0.0 |  0.00
Modify  | 0.78691    | 0.78691    | 0.78691    |   0.0 |  0.19
Other   |            | 0.1024     |            |       |  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:      532794.0 ave      532794 max      532794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532794
Ave neighs/atom = 133.19850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.393189402899, Press = -0.408927541859242
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   -13898.426   -13898.426   -14028.185   -14028.185    251.02727    251.02727    47825.655    47825.655    116.88555    116.88555 
   29000   -13895.709   -13895.709    -14026.63    -14026.63    253.27562    253.27562    47850.953    47850.953   -522.17222   -522.17222 
Loop time of 361.651 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.459 hours/ns, 2.765 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 360.74     | 360.74     | 360.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14894    | 0.14894    | 0.14894    |   0.0 |  0.04
Output  | 0.00017957 | 0.00017957 | 0.00017957 |   0.0 |  0.00
Modify  | 0.6691     | 0.6691     | 0.6691     |   0.0 |  0.19
Other   |            | 0.09326    |            |       |  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:      532776.0 ave      532776 max      532776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532776
Ave neighs/atom = 133.19400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.357344598296, Press = 0.57934068847685
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   -13895.709   -13895.709    -14026.63    -14026.63    253.27562    253.27562    47850.953    47850.953   -522.17222   -522.17222 
   30000   -13900.718   -13900.718   -14030.598   -14030.598    251.26191    251.26191    47854.756    47854.756   -1019.2666   -1019.2666 
Loop time of 388.47 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.908 hours/ns, 2.574 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    | 387.49     | 387.49     | 387.49     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15301    | 0.15301    | 0.15301    |   0.0 |  0.04
Output  | 0.00022827 | 0.00022827 | 0.00022827 |   0.0 |  0.00
Modify  | 0.73263    | 0.73263    | 0.73263    |   0.0 |  0.19
Other   |            | 0.09897    |            |       |  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:      532298.0 ave      532298 max      532298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532298
Ave neighs/atom = 133.07450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.310334897463, Press = 1.71756067301844
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   -13900.718   -13900.718   -14030.598   -14030.598    251.26191    251.26191    47854.756    47854.756   -1019.2666   -1019.2666 
   31000   -13895.775   -13895.775   -14027.341   -14027.341    254.52495    254.52495    47824.111    47824.111    172.28675    172.28675 
Loop time of 423.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.670 hours/ns, 2.361 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.51     | 422.51     | 422.51     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16472    | 0.16472    | 0.16472    |   0.0 |  0.04
Output  | 0.00024621 | 0.00024621 | 0.00024621 |   0.0 |  0.00
Modify  | 0.82888    | 0.82888    | 0.82888    |   0.0 |  0.20
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:      532678.0 ave      532678 max      532678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532678
Ave neighs/atom = 133.16950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.307667134397, Press = 1.72464968631804
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   -13895.775   -13895.775   -14027.341   -14027.341    254.52495    254.52495    47824.111    47824.111    172.28675    172.28675 
   32000   -13898.735   -13898.735   -14032.269   -14032.269    258.32953    258.32953    47823.466    47823.466   -230.86734   -230.86734 
Loop time of 424.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.835 hours/ns, 2.357 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    | 423.11     | 423.11     | 423.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1642     | 0.1642     | 0.1642     |   0.0 |  0.04
Output  | 0.00017985 | 0.00017985 | 0.00017985 |   0.0 |  0.00
Modify  | 0.82386    | 0.82386    | 0.82386    |   0.0 |  0.19
Other   |            | 0.1049     |            |       |  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:      532616.0 ave      532616 max      532616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532616
Ave neighs/atom = 133.15400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.30053959586, Press = 0.640427692413531
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   -13898.735   -13898.735   -14032.269   -14032.269    258.32953    258.32953    47823.466    47823.466   -230.86734   -230.86734 
   33000   -13893.752   -13893.752   -14026.643   -14026.643    257.08776    257.08776    47832.094    47832.094    237.80961    237.80961 
Loop time of 421.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.056 hours/ns, 2.373 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.31     | 420.31     | 420.31     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16449    | 0.16449    | 0.16449    |   0.0 |  0.04
Output  | 0.00018091 | 0.00018091 | 0.00018091 |   0.0 |  0.00
Modify  | 0.818      | 0.818      | 0.818      |   0.0 |  0.19
Other   |            | 0.1047     |            |       |  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:      533130.0 ave      533130 max      533130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533130
Ave neighs/atom = 133.28250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.349466105622, Press = 0.868766165442012
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   -13893.752   -13893.752   -14026.643   -14026.643    257.08776    257.08776    47832.094    47832.094    237.80961    237.80961 
   34000   -13896.734   -13896.734   -14027.901   -14027.901    253.75041    253.75041    47818.804    47818.804    373.48151    373.48151 
Loop time of 422.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.450 hours/ns, 2.365 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    | 421.72     | 421.72     | 421.72     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16401    | 0.16401    | 0.16401    |   0.0 |  0.04
Output  | 0.00018033 | 0.00018033 | 0.00018033 |   0.0 |  0.00
Modify  | 0.83064    | 0.83064    | 0.83064    |   0.0 |  0.20
Other   |            | 0.1049     |            |       |  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:      532424.0 ave      532424 max      532424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532424
Ave neighs/atom = 133.10600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.341465105955, Press = 0.846991177742936
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   -13896.734   -13896.734   -14027.901   -14027.901    253.75041    253.75041    47818.804    47818.804    373.48151    373.48151 
   35000    -13903.72    -13903.72   -14029.862   -14029.862    244.03062    244.03062     47712.31     47712.31    3069.1303    3069.1303 
Loop time of 404.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.429 hours/ns, 2.471 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.7      | 403.7      | 403.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16048    | 0.16048    | 0.16048    |   0.0 |  0.04
Output  | 0.00018232 | 0.00018232 | 0.00018232 |   0.0 |  0.00
Modify  | 0.78294    | 0.78294    | 0.78294    |   0.0 |  0.19
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:        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:      532638.0 ave      532638 max      532638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 532638
Ave neighs/atom = 133.15950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.309239267132, Press = 2.75288642553558
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    -13903.72    -13903.72   -14029.862   -14029.862    244.03062    244.03062     47712.31     47712.31    3069.1303    3069.1303 
   36000   -13895.852   -13895.852   -14027.667   -14027.667    255.00505    255.00505    47770.754    47770.754    1818.0541    1818.0541 
Loop time of 413.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.858 hours/ns, 2.418 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    | 412.42     | 412.42     | 412.42     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1622     | 0.1622     | 0.1622     |   0.0 |  0.04
Output  | 0.00029754 | 0.00029754 | 0.00029754 |   0.0 |  0.00
Modify  | 0.79788    | 0.79788    | 0.79788    |   0.0 |  0.19
Other   |            | 0.104      |            |       |  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:      533202.0 ave      533202 max      533202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 533202
Ave neighs/atom = 133.30050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.275309256748, Press = 0.77206445549331
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   -13895.852   -13895.852   -14027.667   -14027.667    255.00505    255.00505    47770.754    47770.754    1818.0541    1818.0541 
   37000   -13895.852   -13895.852   -14026.718   -14026.718    253.16917    253.16917    47781.585    47781.585    1570.1088    1570.1088 
Loop time of 411.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.351 hours/ns, 2.429 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    | 410.6      | 410.6      | 410.6      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16018    | 0.16018    | 0.16018    |   0.0 |  0.04
Output  | 0.00027533 | 0.00027533 | 0.00027533 |   0.0 |  0.00
Modify  | 0.79867    | 0.79867    | 0.79867    |   0.0 |  0.19
Other   |            | 0.104      |            |       |  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:      532798.0 ave      532798 max      532798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0