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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.6133156493306164*${_u_distance}
variable latticeconst_converted equal 3.6133156493306164*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61331564933062
Lattice spacing in x,y,z = 3.6133156 3.6133156 3.6133156
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (36.133156 36.133156 36.133156)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimLee_2008_CuZr__MO_407917731909_000
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_407917731909_000#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 395.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.853 hours/ns, 2.529 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    | 394.44     | 394.44     | 394.44     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16       | 0.16       | 0.16       |   0.0 |  0.04
Output  | 0.00022542 | 0.00022542 | 0.00022542 |   0.0 |  0.00
Modify  | 0.76573    | 0.76573    | 0.76573    |   0.0 |  0.19
Other   |            | 0.1054     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 418.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.111 hours/ns, 2.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 416.93     | 416.93     | 416.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16532    | 0.16532    | 0.16532    |   0.0 |  0.04
Output  | 0.00025095 | 0.00025095 | 0.00025095 |   0.0 |  0.00
Modify  | 0.79496    | 0.79496    | 0.79496    |   0.0 |  0.19
Other   |            | 0.106      |            |       |  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:      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 416.158 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.600 hours/ns, 2.403 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    | 415.1      | 415.1      | 415.1      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16334    | 0.16334    | 0.16334    |   0.0 |  0.04
Output  | 0.00021626 | 0.00021626 | 0.00021626 |   0.0 |  0.00
Modify  | 0.78624    | 0.78624    | 0.78624    |   0.0 |  0.19
Other   |            | 0.1059     |            |       |  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 400.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.183 hours/ns, 2.498 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 399.25     | 399.25     | 399.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.161      | 0.161      | 0.161      |   0.0 |  0.04
Output  | 0.00021584 | 0.00021584 | 0.00021584 |   0.0 |  0.00
Modify  | 0.7434     | 0.7434     | 0.7434     |   0.0 |  0.19
Other   |            | 0.1012     |            |       |  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 413.153 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.765 hours/ns, 2.420 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.11     | 412.11     | 412.11     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16152    | 0.16152    | 0.16152    |   0.0 |  0.04
Output  | 0.00018179 | 0.00018179 | 0.00018179 |   0.0 |  0.00
Modify  | 0.77796    | 0.77796    | 0.77796    |   0.0 |  0.19
Other   |            | 0.106      |            |       |  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 380.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.612 hours/ns, 2.630 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    | 379.24     | 379.24     | 379.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.04
Output  | 0.00021718 | 0.00021718 | 0.00021718 |   0.0 |  0.00
Modify  | 0.71396    | 0.71396    | 0.71396    |   0.0 |  0.19
Other   |            | 0.09983    |            |       |  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:      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 385.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.199 hours/ns, 2.591 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    | 384.93     | 384.93     | 384.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1529     | 0.1529     | 0.1529     |   0.0 |  0.04
Output  | 0.00022765 | 0.00022765 | 0.00022765 |   0.0 |  0.00
Modify  | 0.7322     | 0.7322     | 0.7322     |   0.0 |  0.19
Other   |            | 0.1007     |            |       |  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:      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 389.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.178 hours/ns, 2.568 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    | 388.44     | 388.44     | 388.44     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15485    | 0.15485    | 0.15485    |   0.0 |  0.04
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.73994    | 0.73994    | 0.73994    |   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:      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 405.607 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.669 hours/ns, 2.465 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 404.57     | 404.57     | 404.57     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15902    | 0.15902    | 0.15902    |   0.0 |  0.04
Output  | 0.00017909 | 0.00017909 | 0.00017909 |   0.0 |  0.00
Modify  | 0.77957    | 0.77957    | 0.77957    |   0.0 |  0.19
Other   |            | 0.1035     |            |       |  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 385.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.092 hours/ns, 2.594 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    | 384.56     | 384.56     | 384.56     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1515     | 0.1515     | 0.1515     |   0.0 |  0.04
Output  | 0.0002919  | 0.0002919  | 0.0002919  |   0.0 |  0.00
Modify  | 0.72401    | 0.72401    | 0.72401    |   0.0 |  0.19
Other   |            | 0.0993     |            |       |  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 392.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.892 hours/ns, 2.551 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    | 391.01     | 391.01     | 391.01     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15415    | 0.15415    | 0.15415    |   0.0 |  0.04
Output  | 0.0001803  | 0.0001803  | 0.0001803  |   0.0 |  0.00
Modify  | 0.74163    | 0.74163    | 0.74163    |   0.0 |  0.19
Other   |            | 0.1013     |            |       |  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 362.528 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.702 hours/ns, 2.758 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.62     | 361.62     | 361.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1469     | 0.1469     | 0.1469     |   0.0 |  0.04
Output  | 0.00018156 | 0.00018156 | 0.00018156 |   0.0 |  0.00
Modify  | 0.66783    | 0.66783    | 0.66783    |   0.0 |  0.18
Other   |            | 0.09424    |            |       |  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:      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 363.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.885 hours/ns, 2.753 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    | 362.28     | 362.28     | 362.28     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14557    | 0.14557    | 0.14557    |   0.0 |  0.04
Output  | 0.00022838 | 0.00022838 | 0.00022838 |   0.0 |  0.00
Modify  | 0.66841    | 0.66841    | 0.66841    |   0.0 |  0.18
Other   |            | 0.09403    |            |       |  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:      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 363.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.844 hours/ns, 2.755 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 362.13     | 362.13     | 362.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14618    | 0.14618    | 0.14618    |   0.0 |  0.04
Output  | 0.00017812 | 0.00017812 | 0.00017812 |   0.0 |  0.00
Modify  | 0.66841    | 0.66841    | 0.66841    |   0.0 |  0.18
Other   |            | 0.09406    |            |       |  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 362.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.745 hours/ns, 2.757 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.77     | 361.77     | 361.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14612    | 0.14612    | 0.14612    |   0.0 |  0.04
Output  | 0.00022412 | 0.00022412 | 0.00022412 |   0.0 |  0.00
Modify  | 0.66731    | 0.66731    | 0.66731    |   0.0 |  0.18
Other   |            | 0.09434    |            |       |  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:      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 362.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.670 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.5      | 361.5      | 361.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14575    | 0.14575    | 0.14575    |   0.0 |  0.04
Output  | 0.00017767 | 0.00017767 | 0.00017767 |   0.0 |  0.00
Modify  | 0.66898    | 0.66898    | 0.66898    |   0.0 |  0.18
Other   |            | 0.09468    |            |       |  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 361.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.485 hours/ns, 2.764 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    | 360.84     | 360.84     | 360.84     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14614    | 0.14614    | 0.14614    |   0.0 |  0.04
Output  | 0.00017811 | 0.00017811 | 0.00017811 |   0.0 |  0.00
Modify  | 0.66857    | 0.66857    | 0.66857    |   0.0 |  0.18
Other   |            | 0.09353    |            |       |  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 362.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.712 hours/ns, 2.758 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    | 361.65     | 361.65     | 361.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14521    | 0.14521    | 0.14521    |   0.0 |  0.04
Output  | 0.00022637 | 0.00022637 | 0.00022637 |   0.0 |  0.00
Modify  | 0.66825    | 0.66825    | 0.66825    |   0.0 |  0.18
Other   |            | 0.09461    |            |       |  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:      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 362.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.617 hours/ns, 2.761 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    | 361.31     | 361.31     | 361.31     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1463     | 0.1463     | 0.1463     |   0.0 |  0.04
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.66772    | 0.66772    | 0.66772    |   0.0 |  0.18
Other   |            | 0.0944     |            |       |  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.966 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 361.06     | 361.06     | 361.06     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14557    | 0.14557    | 0.14557    |   0.0 |  0.04
Output  | 0.00017812 | 0.00017812 | 0.00017812 |   0.0 |  0.00
Modify  | 0.66785    | 0.66785    | 0.66785    |   0.0 |  0.18
Other   |            | 0.09416    |            |       |  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 374.689 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 104.080 hours/ns, 2.669 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.74     | 373.74     | 373.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14824    | 0.14824    | 0.14824    |   0.0 |  0.04
Output  | 0.00023217 | 0.00023217 | 0.00023217 |   0.0 |  0.00
Modify  | 0.70058    | 0.70058    | 0.70058    |   0.0 |  0.19
Other   |            | 0.09826    |            |       |  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 419.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.445 hours/ns, 2.385 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 418.11     | 418.11     | 418.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16312    | 0.16312    | 0.16312    |   0.0 |  0.04
Output  | 0.0002302  | 0.0002302  | 0.0002302  |   0.0 |  0.00
Modify  | 0.81773    | 0.81773    | 0.81773    |   0.0 |  0.20
Other   |            | 0.1074     |            |       |  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 374.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.966 hours/ns, 2.672 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    | 373.33     | 373.33     | 373.33     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14784    | 0.14784    | 0.14784    |   0.0 |  0.04
Output  | 0.00024988 | 0.00024988 | 0.00024988 |   0.0 |  0.00
Modify  | 0.70389    | 0.70389    | 0.70389    |   0.0 |  0.19
Other   |            | 0.09995    |            |       |  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 398.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.640 hours/ns, 2.511 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.3      | 397.3      | 397.3      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15417    | 0.15417    | 0.15417    |   0.0 |  0.04
Output  | 0.00017882 | 0.00017882 | 0.00017882 |   0.0 |  0.00
Modify  | 0.75509    | 0.75509    | 0.75509    |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  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:      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 401.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.508 hours/ns, 2.491 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    | 400.41     | 400.41     | 400.41     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15303    | 0.15303    | 0.15303    |   0.0 |  0.04
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.76663    | 0.76663    | 0.76663    |   0.0 |  0.19
Other   |            | 0.1025     |            |       |  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 390.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.459 hours/ns, 2.561 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.46     | 389.46     | 389.46     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15082    | 0.15082    | 0.15082    |   0.0 |  0.04
Output  | 0.00018383 | 0.00018383 | 0.00018383 |   0.0 |  0.00
Modify  | 0.73856    | 0.73856    | 0.73856    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  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 362.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.814 hours/ns, 2.755 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 362.02     | 362.02     | 362.02     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14385    | 0.14385    | 0.14385    |   0.0 |  0.04
Output  | 0.00018115 | 0.00018115 | 0.00018115 |   0.0 |  0.00
Modify  | 0.67094    | 0.67094    | 0.67094    |   0.0 |  0.18
Other   |            | 0.09357    |            |       |  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 369.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.681 hours/ns, 2.705 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    | 368.73     | 368.73     | 368.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14631    | 0.14631    | 0.14631    |   0.0 |  0.04
Output  | 0.00017991 | 0.00017991 | 0.00017991 |   0.0 |  0.00
Modify  | 0.68545    | 0.68545    | 0.68545    |   0.0 |  0.19
Other   |            | 0.09518    |            |       |  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.862 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 360.96     | 360.96     | 360.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14496    | 0.14496    | 0.14496    |   0.0 |  0.04
Output  | 0.00018522 | 0.00018522 | 0.00018522 |   0.0 |  0.00
Modify  | 0.66663    | 0.66663    | 0.66663    |   0.0 |  0.18
Other   |            | 0.09483    |            |       |  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 362.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.681 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.54     | 361.54     | 361.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14433    | 0.14433    | 0.14433    |   0.0 |  0.04
Output  | 0.00017976 | 0.00017976 | 0.00017976 |   0.0 |  0.00
Modify  | 0.66985    | 0.66985    | 0.66985    |   0.0 |  0.18
Other   |            | 0.09471    |            |       |  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 421.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.194 hours/ns, 2.370 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.81     | 420.81     | 420.81     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16203    | 0.16203    | 0.16203    |   0.0 |  0.04
Output  | 0.00023388 | 0.00023388 | 0.00023388 |   0.0 |  0.00
Modify  | 0.82392    | 0.82392    | 0.82392    |   0.0 |  0.20
Other   |            | 0.1074     |            |       |  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:      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 423.574 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.659 hours/ns, 2.361 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.48     | 422.48     | 422.48     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16379    | 0.16379    | 0.16379    |   0.0 |  0.04
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.81839    | 0.81839    | 0.81839    |   0.0 |  0.19
Other   |            | 0.1071     |            |       |  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:      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 375.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.307 hours/ns, 2.663 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    | 374.55     | 374.55     | 374.55     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.148      | 0.148      | 0.148      |   0.0 |  0.04
Output  | 0.00023157 | 0.00023157 | 0.00023157 |   0.0 |  0.00
Modify  | 0.70409    | 0.70409    | 0.70409    |   0.0 |  0.19
Other   |            | 0.09957    |            |       |  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:      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 424.226 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.841 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.13     | 423.13     | 423.13     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16165    | 0.16165    | 0.16165    |   0.0 |  0.04
Output  | 0.00017797 | 0.00017797 | 0.00017797 |   0.0 |  0.00
Modify  | 0.82835    | 0.82835    | 0.82835    |   0.0 |  0.20
Other   |            | 0.1062     |            |       |  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:      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 425.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.259 hours/ns, 2.349 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.63     | 424.63     | 424.63     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16102    | 0.16102    | 0.16102    |   0.0 |  0.04
Output  | 0.00017953 | 0.00017953 | 0.00017953 |   0.0 |  0.00
Modify  | 0.82985    | 0.82985    | 0.82985    |   0.0 |  0.19
Other   |            | 0.1071     |            |       |  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 361.46 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.55     | 360.55     | 360.55     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14191    | 0.14191    | 0.14191    |   0.0 |  0.04
Output  | 0.0001777  | 0.0001777  | 0.0001777  |   0.0 |  0.00
Modify  | 0.66759    | 0.66759    | 0.66759    |   0.0 |  0.18
Other   |            | 0.09819    |            |       |  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 361.881 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 360.97     | 360.97     | 360.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14281    | 0.14281    | 0.14281    |   0.0 |  0.04
Output  | 0.00023427 | 0.00023427 | 0.00023427 |   0.0 |  0.00
Modify  | 0.66771    | 0.66771    | 0.66771    |   0.0 |  0.18
Other   |            | 0.09711    |            |       |  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