# 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.9173715263605122*${_u_distance}
variable latticeconst_converted equal 3.9173715263605122*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737152636051
Lattice spacing in x,y,z = 3.9173715 3.9173715 3.9173715
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 (39.173715 39.173715 39.173715)
  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 (39.173715 39.173715 39.173715)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtAl__MO_793141037706_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

# initial volume
variable      v equal vol        # assign formula
variable      V0 equal ${v}    # evaluate initial value
variable      V0 equal 60115.198698193    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.198698193/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.198698193/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 60115.198698193/(1*1*${_u_distance})
variable      V0_metal equal 60115.198698193/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 60115.198698193*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 60115.198698193 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_793141037706_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22928.467   -22928.467       -23080       -23080       293.15       293.15    60115.199    60115.199    2692.3989    2692.3989 
    1000   -22768.752   -22768.752   -22929.582   -22929.582    311.13782    311.13782    60647.371    60647.371   -89.207769   -89.207769 
Loop time of 423.855 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.738 hours/ns, 2.359 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    | 422.74     | 422.74     | 422.74     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21967    | 0.21967    | 0.21967    |   0.0 |  0.05
Output  | 0.00029623 | 0.00029623 | 0.00029623 |   0.0 |  0.00
Modify  | 0.78872    | 0.78872    | 0.78872    |   0.0 |  0.19
Other   |            | 0.1081     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -22768.752   -22768.752   -22929.582   -22929.582    311.13782    311.13782    60647.371    60647.371   -89.207769   -89.207769 
    2000   -22777.151   -22777.151   -22933.308   -22933.308    302.09624    302.09624    60659.733    60659.733   -1364.6644   -1364.6644 
Loop time of 434.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.580 hours/ns, 2.304 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    | 433        | 433        | 433        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21593    | 0.21593    | 0.21593    |   0.0 |  0.05
Output  | 0.00025569 | 0.00025569 | 0.00025569 |   0.0 |  0.00
Modify  | 0.76919    | 0.76919    | 0.76919    |   0.0 |  0.18
Other   |            | 0.1069     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8168.00 ave        8168 max        8168 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:      558850.0 ave      558850 max      558850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558850
Ave neighs/atom = 139.71250
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -22777.151   -22777.151   -22933.308   -22933.308    302.09624    302.09624    60659.733    60659.733   -1364.6644   -1364.6644 
    3000   -22778.632   -22778.632   -22933.568   -22933.568    299.73463    299.73463    60671.347    60671.347   -2001.8155   -2001.8155 
Loop time of 447.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.422 hours/ns, 2.233 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    | 446.77     | 446.77     | 446.77     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22055    | 0.22055    | 0.22055    |   0.0 |  0.05
Output  | 0.00021903 | 0.00021903 | 0.00021903 |   0.0 |  0.00
Modify  | 0.81322    | 0.81322    | 0.81322    |   0.0 |  0.18
Other   |            | 0.1113     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8171.00 ave        8171 max        8171 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:      558932.0 ave      558932 max      558932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558932
Ave neighs/atom = 139.73300
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22778.632   -22778.632   -22933.568   -22933.568    299.73463    299.73463    60671.347    60671.347   -2001.8155   -2001.8155 
    4000   -22774.074   -22774.074   -22931.335   -22931.335    304.23199    304.23199    60585.726    60585.726    2642.9168    2642.9168 
Loop time of 448.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.492 hours/ns, 2.231 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    | 447.01     | 447.01     | 447.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22619    | 0.22619    | 0.22619    |   0.0 |  0.05
Output  | 0.00021555 | 0.00021555 | 0.00021555 |   0.0 |  0.00
Modify  | 0.8195     | 0.8195     | 0.8195     |   0.0 |  0.18
Other   |            | 0.1119     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8164.00 ave        8164 max        8164 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:      558794.0 ave      558794 max      558794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558794
Ave neighs/atom = 139.69850
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -22774.074   -22774.074   -22931.335   -22931.335    304.23199    304.23199    60585.726    60585.726    2642.9168    2642.9168 
    5000   -22778.839   -22778.839   -22927.907   -22927.907    288.38119    288.38119    60654.154    60654.154   -502.07911   -502.07911 
Loop time of 445.566 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.768 hours/ns, 2.244 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    | 444.41     | 444.41     | 444.41     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22312    | 0.22312    | 0.22312    |   0.0 |  0.05
Output  | 0.00018327 | 0.00018327 | 0.00018327 |   0.0 |  0.00
Modify  | 0.81893    | 0.81893    | 0.81893    |   0.0 |  0.18
Other   |            | 0.1095     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8179.00 ave        8179 max        8179 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:      559046.0 ave      559046 max      559046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559046
Ave neighs/atom = 139.76150
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 = 296.183636087725, Press = 188.057698928143
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -22778.839   -22778.839   -22927.907   -22927.907    288.38119    288.38119    60654.154    60654.154   -502.07911   -502.07911 
    6000   -22778.061   -22778.061   -22931.269   -22931.269    296.39024    296.39024    60633.757    60633.757    136.73192    136.73192 
Loop time of 438.326 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.757 hours/ns, 2.281 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    | 437.17     | 437.17     | 437.17     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22143    | 0.22143    | 0.22143    |   0.0 |  0.05
Output  | 0.00018106 | 0.00018106 | 0.00018106 |   0.0 |  0.00
Modify  | 0.82929    | 0.82929    | 0.82929    |   0.0 |  0.19
Other   |            | 0.11       |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8148.00 ave        8148 max        8148 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:      558728.0 ave      558728 max      558728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558728
Ave neighs/atom = 139.68200
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 = 293.579278644502, Press = 49.0079367791214
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22778.061   -22778.061   -22931.269   -22931.269    296.39024    296.39024    60633.757    60633.757    136.73192    136.73192 
    7000   -22775.928   -22775.928   -22927.187   -22927.187    292.62024    292.62024    60613.362    60613.362     1571.155     1571.155 
Loop time of 432.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.139 hours/ns, 2.312 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    | 431.36     | 431.36     | 431.36     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21857    | 0.21857    | 0.21857    |   0.0 |  0.05
Output  | 0.00024969 | 0.00024969 | 0.00024969 |   0.0 |  0.00
Modify  | 0.81408    | 0.81408    | 0.81408    |   0.0 |  0.19
Other   |            | 0.11       |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8169.00 ave        8169 max        8169 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:      558924.0 ave      558924 max      558924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558924
Ave neighs/atom = 139.73100
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 = 293.010404600681, Press = 18.8567062544873
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -22775.928   -22775.928   -22927.187   -22927.187    292.62024    292.62024    60613.362    60613.362     1571.155     1571.155 
    8000   -22777.617   -22777.617   -22928.377   -22928.377    291.65423    291.65423    60638.935    60638.935    349.27568    349.27568 
Loop time of 415.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.289 hours/ns, 2.409 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    | 413.97     | 413.97     | 413.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21032    | 0.21032    | 0.21032    |   0.0 |  0.05
Output  | 0.00018014 | 0.00018014 | 0.00018014 |   0.0 |  0.00
Modify  | 0.76031    | 0.76031    | 0.76031    |   0.0 |  0.18
Other   |            | 0.1042     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8164.00 ave        8164 max        8164 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:      558822.0 ave      558822 max      558822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558822
Ave neighs/atom = 139.70550
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 = 293.339273844992, Press = 4.4099023821434
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22777.617   -22777.617   -22928.377   -22928.377    291.65423    291.65423    60638.935    60638.935    349.27568    349.27568 
    9000   -22779.149   -22779.149   -22931.341   -22931.341    294.42598    294.42598    60623.183    60623.183    608.21968    608.21968 
Loop time of 382.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.279 hours/ns, 2.614 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    | 381.64     | 381.64     | 381.64     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19789    | 0.19789    | 0.19789    |   0.0 |  0.05
Output  | 0.00017728 | 0.00017728 | 0.00017728 |   0.0 |  0.00
Modify  | 0.67197    | 0.67197    | 0.67197    |   0.0 |  0.18
Other   |            | 0.09677    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 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:      558852.0 ave      558852 max      558852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558852
Ave neighs/atom = 139.71300
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 = 293.080791188394, Press = 18.4693987251175
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22779.149   -22779.149   -22931.341   -22931.341    294.42598    294.42598    60623.183    60623.183    608.21968    608.21968 
   10000   -22776.631   -22776.631    -22927.23    -22927.23    291.34377    291.34377     60626.95     60626.95    958.33781    958.33781 
Loop time of 399.83 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.064 hours/ns, 2.501 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    | 398.8      | 398.8      | 398.8      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20285    | 0.20285    | 0.20285    |   0.0 |  0.05
Output  | 0.00018237 | 0.00018237 | 0.00018237 |   0.0 |  0.00
Modify  | 0.7212     | 0.7212     | 0.7212     |   0.0 |  0.18
Other   |            | 0.1031     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 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:      558910.0 ave      558910 max      558910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558910
Ave neighs/atom = 139.72750
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 = 293.264868192366, Press = 9.7317946276327
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22776.631   -22776.631    -22927.23    -22927.23    291.34377    291.34377     60626.95     60626.95    958.33781    958.33781 
   11000   -22777.835   -22777.835   -22930.387   -22930.387    295.12375    295.12375    60637.167    60637.167    161.02731    161.02731 
Loop time of 429.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.415 hours/ns, 2.326 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.76     | 428.76     | 428.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21772    | 0.21772    | 0.21772    |   0.0 |  0.05
Output  | 0.00017717 | 0.00017717 | 0.00017717 |   0.0 |  0.00
Modify  | 0.81185    | 0.81185    | 0.81185    |   0.0 |  0.19
Other   |            | 0.109      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558836.0 ave      558836 max      558836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558836
Ave neighs/atom = 139.70900
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 = 293.201583442789, Press = 0.566790502847631
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22777.835   -22777.835   -22930.387   -22930.387    295.12375    295.12375    60637.167    60637.167    161.02731    161.02731 
   12000   -22779.929   -22779.929   -22928.448   -22928.448    287.31861    287.31861    60655.676    60655.676   -495.33214   -495.33214 
Loop time of 415.229 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.341 hours/ns, 2.408 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 414.11     | 414.11     | 414.11     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21571    | 0.21571    | 0.21571    |   0.0 |  0.05
Output  | 0.00018128 | 0.00018128 | 0.00018128 |   0.0 |  0.00
Modify  | 0.79254    | 0.79254    | 0.79254    |   0.0 |  0.19
Other   |            | 0.108      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8148.00 ave        8148 max        8148 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:      558790.0 ave      558790 max      558790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558790
Ave neighs/atom = 139.69750
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 = 293.068926940466, Press = 0.602580422313223
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22779.929   -22779.929   -22928.448   -22928.448    287.31861    287.31861    60655.676    60655.676   -495.33214   -495.33214 
   13000    -22775.11    -22775.11   -22929.727   -22929.727    299.11847    299.11847    60666.323    60666.323    -1107.681    -1107.681 
Loop time of 394.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.616 hours/ns, 2.534 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.61     | 393.61     | 393.61     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20345    | 0.20345    | 0.20345    |   0.0 |  0.05
Output  | 0.00018632 | 0.00018632 | 0.00018632 |   0.0 |  0.00
Modify  | 0.70631    | 0.70631    | 0.70631    |   0.0 |  0.18
Other   |            | 0.1008     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8163.00 ave        8163 max        8163 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:      558868.0 ave      558868 max      558868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558868
Ave neighs/atom = 139.71700
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 = 292.884102550513, Press = 2.96777877784799
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -22775.11    -22775.11   -22929.727   -22929.727    299.11847    299.11847    60666.323    60666.323    -1107.681    -1107.681 
   14000   -22778.571   -22778.571   -22932.351   -22932.351    297.49799    297.49799     60641.23     60641.23   -319.96831   -319.96831 
Loop time of 442.514 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.921 hours/ns, 2.260 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    | 441.34     | 441.34     | 441.34     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.226      | 0.226      | 0.226      |   0.0 |  0.05
Output  | 0.00018098 | 0.00018098 | 0.00018098 |   0.0 |  0.00
Modify  | 0.84361    | 0.84361    | 0.84361    |   0.0 |  0.19
Other   |            | 0.1083     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558744.0 ave      558744 max      558744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558744
Ave neighs/atom = 139.68600
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 = 292.896753824482, Press = 3.41144645152241
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22778.571   -22778.571   -22932.351   -22932.351    297.49799    297.49799     60641.23     60641.23   -319.96831   -319.96831 
   15000   -22778.592   -22778.592   -22928.738   -22928.738    290.46751    290.46751    60631.113    60631.113    654.35817    654.35817 
Loop time of 443.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.204 hours/ns, 2.255 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    | 442.37     | 442.37     | 442.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21926    | 0.21926    | 0.21926    |   0.0 |  0.05
Output  | 0.00023381 | 0.00023381 | 0.00023381 |   0.0 |  0.00
Modify  | 0.83028    | 0.83028    | 0.83028    |   0.0 |  0.19
Other   |            | 0.111      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8155.00 ave        8155 max        8155 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:      559004.0 ave      559004 max      559004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559004
Ave neighs/atom = 139.75100
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 = 292.752243149722, Press = 3.4777635414595
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22778.592   -22778.592   -22928.738   -22928.738    290.46751    290.46751    60631.113    60631.113    654.35817    654.35817 
   16000   -22777.279   -22777.279   -22928.028   -22928.028     291.6332     291.6332     60595.84     60595.84    2296.3936    2296.3936 
Loop time of 437.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.482 hours/ns, 2.287 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    | 436.17     | 436.17     | 436.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22082    | 0.22082    | 0.22082    |   0.0 |  0.05
Output  | 0.00017992 | 0.00017992 | 0.00017992 |   0.0 |  0.00
Modify  | 0.83113    | 0.83113    | 0.83113    |   0.0 |  0.19
Other   |            | 0.1096     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558866.0 ave      558866 max      558866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558866
Ave neighs/atom = 139.71650
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 = 292.763247957836, Press = 4.78511396839017
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22777.279   -22777.279   -22928.028   -22928.028     291.6332     291.6332     60595.84     60595.84    2296.3936    2296.3936 
   17000   -22778.181   -22778.181   -22931.071   -22931.071     295.7754     295.7754    60592.192    60592.192    2039.0784    2039.0784 
Loop time of 436.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.180 hours/ns, 2.292 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 435.1      | 435.1      | 435.1      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21887    | 0.21887    | 0.21887    |   0.0 |  0.05
Output  | 0.0001823  | 0.0001823  | 0.0001823  |   0.0 |  0.00
Modify  | 0.82396    | 0.82396    | 0.82396    |   0.0 |  0.19
Other   |            | 0.1091     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8169.00 ave        8169 max        8169 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:      558880.0 ave      558880 max      558880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558880
Ave neighs/atom = 139.72000
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 = 292.870695698345, Press = 2.35776066911876
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22778.181   -22778.181   -22931.071   -22931.071     295.7754     295.7754    60592.192    60592.192    2039.0784    2039.0784 
   18000   -22775.196   -22775.196    -22926.23    -22926.23    292.18581    292.18581    60595.491    60595.491    2601.2266    2601.2266 
Loop time of 383.096 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.416 hours/ns, 2.610 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    | 382.13     | 382.13     | 382.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1985     | 0.1985     | 0.1985     |   0.0 |  0.05
Output  | 0.00018075 | 0.00018075 | 0.00018075 |   0.0 |  0.00
Modify  | 0.67289    | 0.67289    | 0.67289    |   0.0 |  0.18
Other   |            | 0.09803    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 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:      558894.0 ave      558894 max      558894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558894
Ave neighs/atom = 139.72350
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 = 292.981825849358, Press = -0.292768206047999
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22775.196   -22775.196    -22926.23    -22926.23    292.18581    292.18581    60595.491    60595.491    2601.2266    2601.2266 
   19000   -22776.346   -22776.346   -22927.552   -22927.552    292.51825    292.51825    60648.971    60648.971   -43.524905   -43.524905 
Loop time of 401.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.539 hours/ns, 2.490 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    | 400.51     | 400.51     | 400.51     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2063     | 0.2063     | 0.2063     |   0.0 |  0.05
Output  | 0.00018306 | 0.00018306 | 0.00018306 |   0.0 |  0.00
Modify  | 0.72654    | 0.72654    | 0.72654    |   0.0 |  0.18
Other   |            | 0.1021     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8151.00 ave        8151 max        8151 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:      558814.0 ave      558814 max      558814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558814
Ave neighs/atom = 139.70350
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 = 292.962319595562, Press = 2.90388470339093
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -22776.346   -22776.346   -22927.552   -22927.552    292.51825    292.51825    60648.971    60648.971   -43.524905   -43.524905 
   20000   -22778.606   -22778.606   -22929.226   -22929.226     291.3845     291.3845    60630.654    60630.654    554.66833    554.66833 
Loop time of 443.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.076 hours/ns, 2.257 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    | 441.88     | 441.88     | 441.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22706    | 0.22706    | 0.22706    |   0.0 |  0.05
Output  | 0.00023252 | 0.00023252 | 0.00023252 |   0.0 |  0.00
Modify  | 0.85307    | 0.85307    | 0.85307    |   0.0 |  0.19
Other   |            | 0.1115     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8161.00 ave        8161 max        8161 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:      558792.0 ave      558792 max      558792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558792
Ave neighs/atom = 139.69800
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 = 292.913689984746, Press = 1.02726693199723
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22778.606   -22778.606   -22929.226   -22929.226     291.3845     291.3845    60630.654    60630.654    554.66833    554.66833 
   21000   -22778.892   -22778.892   -22931.072   -22931.072    294.40185    294.40185    60638.783    60638.783   -236.23094   -236.23094 
Loop time of 439.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.177 hours/ns, 2.274 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    | 438.69     | 438.69     | 438.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2208     | 0.2208     | 0.2208     |   0.0 |  0.05
Output  | 0.00018104 | 0.00018104 | 0.00018104 |   0.0 |  0.00
Modify  | 0.81962    | 0.81962    | 0.81962    |   0.0 |  0.19
Other   |            | 0.1094     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8175.00 ave        8175 max        8175 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:      558848.0 ave      558848 max      558848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558848
Ave neighs/atom = 139.71200
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 = 292.927612334371, Press = 4.21984798130714
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22778.892   -22778.892   -22931.072   -22931.072    294.40185    294.40185    60638.783    60638.783   -236.23094   -236.23094 
   22000   -22774.544   -22774.544   -22925.509   -22925.509    292.05188    292.05188    60649.263    60649.263     101.8771     101.8771 
Loop time of 423.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.759 hours/ns, 2.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 422.79     | 422.79     | 422.79     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21854    | 0.21854    | 0.21854    |   0.0 |  0.05
Output  | 0.00018123 | 0.00018123 | 0.00018123 |   0.0 |  0.00
Modify  | 0.81472    | 0.81472    | 0.81472    |   0.0 |  0.19
Other   |            | 0.1092     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8170.00 ave        8170 max        8170 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:      558756.0 ave      558756 max      558756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558756
Ave neighs/atom = 139.68900
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 = 292.84098075615, Press = 3.14684405409174
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22774.544   -22774.544   -22925.509   -22925.509    292.05188    292.05188    60649.263    60649.263     101.8771     101.8771 
   23000   -22781.043   -22781.043   -22931.953   -22931.953    291.94555    291.94555      60658.4      60658.4   -1087.5155   -1087.5155 
Loop time of 423.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.743 hours/ns, 2.359 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    | 422.76     | 422.76     | 422.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21347    | 0.21347    | 0.21347    |   0.0 |  0.05
Output  | 0.00018027 | 0.00018027 | 0.00018027 |   0.0 |  0.00
Modify  | 0.78951    | 0.78951    | 0.78951    |   0.0 |  0.19
Other   |            | 0.1078     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8152.00 ave        8152 max        8152 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:      558712.0 ave      558712 max      558712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558712
Ave neighs/atom = 139.67800
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 = 292.842187620133, Press = 1.90695402048371
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22781.043   -22781.043   -22931.953   -22931.953    291.94555    291.94555      60658.4      60658.4   -1087.5155   -1087.5155 
   24000   -22781.256   -22781.256   -22929.061   -22929.061    285.93896    285.93896    60654.812    60654.812   -712.62223   -712.62223 
Loop time of 438.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.913 hours/ns, 2.278 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    | 437.72     | 437.72     | 437.72     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22201    | 0.22201    | 0.22201    |   0.0 |  0.05
Output  | 0.00024284 | 0.00024284 | 0.00024284 |   0.0 |  0.00
Modify  | 0.83724    | 0.83724    | 0.83724    |   0.0 |  0.19
Other   |            | 0.1122     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8169.00 ave        8169 max        8169 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:      558846.0 ave      558846 max      558846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558846
Ave neighs/atom = 139.71150
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 = 292.849484652369, Press = 0.179842586955908
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -22781.256   -22781.256   -22929.061   -22929.061    285.93896    285.93896    60654.812    60654.812   -712.62223   -712.62223 
   25000   -22777.969   -22777.969    -22928.77    -22928.77    291.73548    291.73548    60609.254    60609.254    1618.8669    1618.8669 
Loop time of 442.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.945 hours/ns, 2.259 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    | 441.46     | 441.46     | 441.46     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21878    | 0.21878    | 0.21878    |   0.0 |  0.05
Output  | 0.00017937 | 0.00017937 | 0.00017937 |   0.0 |  0.00
Modify  | 0.81788    | 0.81788    | 0.81788    |   0.0 |  0.18
Other   |            | 0.1088     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8159.00 ave        8159 max        8159 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:      558724.0 ave      558724 max      558724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558724
Ave neighs/atom = 139.68100
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 = 292.808458370613, Press = 1.76655999629756
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22777.969   -22777.969    -22928.77    -22928.77    291.73548    291.73548    60609.254    60609.254    1618.8669    1618.8669 
   26000    -22782.46    -22782.46   -22933.313   -22933.313    291.83462    291.83462    60633.639    60633.639   -178.74509   -178.74509 
Loop time of 434.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.677 hours/ns, 2.302 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    | 433.28     | 433.28     | 433.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21837    | 0.21837    | 0.21837    |   0.0 |  0.05
Output  | 0.00017945 | 0.00017945 | 0.00017945 |   0.0 |  0.00
Modify  | 0.82328    | 0.82328    | 0.82328    |   0.0 |  0.19
Other   |            | 0.1109     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8157.00 ave        8157 max        8157 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:      558862.0 ave      558862 max      558862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558862
Ave neighs/atom = 139.71550
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 = 292.786338888682, Press = -0.339687369062689
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -22782.46    -22782.46   -22933.313   -22933.313    291.83462    291.83462    60633.639    60633.639   -178.74509   -178.74509 
   27000   -22775.432   -22775.432   -22927.298   -22927.298    293.79683    293.79683    60614.774    60614.774      1574.52      1574.52 
Loop time of 413.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.901 hours/ns, 2.418 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 412.55     | 412.55     | 412.55     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21367    | 0.21367    | 0.21367    |   0.0 |  0.05
Output  | 0.00029429 | 0.00029429 | 0.00029429 |   0.0 |  0.00
Modify  | 0.7756     | 0.7756     | 0.7756     |   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:        8162.00 ave        8162 max        8162 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:      558880.0 ave      558880 max      558880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558880
Ave neighs/atom = 139.72000
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 = 292.743067709084, Press = -0.232242236102633
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22775.432   -22775.432   -22927.298   -22927.298    293.79683    293.79683    60614.774    60614.774      1574.52      1574.52 
   28000    -22783.54    -22783.54   -22930.485   -22930.485    284.27534    284.27534    60628.985    60628.985    311.89712    311.89712 
Loop time of 410.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.118 hours/ns, 2.434 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 409.77     | 409.77     | 409.77     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20738    | 0.20738    | 0.20738    |   0.0 |  0.05
Output  | 0.00017714 | 0.00017714 | 0.00017714 |   0.0 |  0.00
Modify  | 0.74657    | 0.74657    | 0.74657    |   0.0 |  0.18
Other   |            | 0.1047     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558798.0 ave      558798 max      558798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558798
Ave neighs/atom = 139.69950
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 = 292.713554637712, Press = 0.600412780215522
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -22783.54    -22783.54   -22930.485   -22930.485    284.27534    284.27534    60628.985    60628.985    311.89712    311.89712 
   29000   -22776.156   -22776.156   -22929.725   -22929.725    297.08957    297.08957    60654.117    60654.117   -566.69898   -566.69898 
Loop time of 423.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.707 hours/ns, 2.360 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    | 422.64     | 422.64     | 422.64     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21167    | 0.21167    | 0.21167    |   0.0 |  0.05
Output  | 0.00018147 | 0.00018147 | 0.00018147 |   0.0 |  0.00
Modify  | 0.7846     | 0.7846     | 0.7846     |   0.0 |  0.19
Other   |            | 0.1084     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8168.00 ave        8168 max        8168 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:      558924.0 ave      558924 max      558924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558924
Ave neighs/atom = 139.73100
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 = 292.652161686602, Press = -0.503738258631964
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -22776.156   -22776.156   -22929.725   -22929.725    297.08957    297.08957    60654.117    60654.117   -566.69898   -566.69898 
   30000   -22776.358   -22776.358   -22928.029   -22928.029    293.41817    293.41817    60649.314    60649.314   -218.99477   -218.99477 
Loop time of 409.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.830 hours/ns, 2.440 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    | 408.74     | 408.74     | 408.74     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20417    | 0.20417    | 0.20417    |   0.0 |  0.05
Output  | 0.00045061 | 0.00045061 | 0.00045061 |   0.0 |  0.00
Modify  | 0.74007    | 0.74007    | 0.74007    |   0.0 |  0.18
Other   |            | 0.104      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558808.0 ave      558808 max      558808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558808
Ave neighs/atom = 139.70200
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 = 292.63900784258, Press = 0.352165181892517
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22776.358   -22776.358   -22928.029   -22928.029    293.41817    293.41817    60649.314    60649.314   -218.99477   -218.99477 
   31000   -22779.523   -22779.523   -22931.258   -22931.258    293.54244    293.54244    60623.895    60623.895    466.60616    466.60616 
Loop time of 438.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.920 hours/ns, 2.278 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    | 437.76     | 437.76     | 437.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21878    | 0.21878    | 0.21878    |   0.0 |  0.05
Output  | 0.00017745 | 0.00017745 | 0.00017745 |   0.0 |  0.00
Modify  | 0.82161    | 0.82161    | 0.82161    |   0.0 |  0.19
Other   |            | 0.1097     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8154.00 ave        8154 max        8154 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:      558846.0 ave      558846 max      558846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558846
Ave neighs/atom = 139.71150
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 = 292.646961209933, Press = 0.208962357411697
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22779.523   -22779.523   -22931.258   -22931.258    293.54244    293.54244    60623.895    60623.895    466.60616    466.60616 
   32000    -22776.94    -22776.94   -22929.325   -22929.325    294.79891    294.79891    60595.301    60595.301    2159.3105    2159.3105 
Loop time of 436.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.267 hours/ns, 2.291 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    | 435.42     | 435.42     | 435.42     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21621    | 0.21621    | 0.21621    |   0.0 |  0.05
Output  | 0.00018198 | 0.00018198 | 0.00018198 |   0.0 |  0.00
Modify  | 0.81619    | 0.81619    | 0.81619    |   0.0 |  0.19
Other   |            | 0.1096     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558916.0 ave      558916 max      558916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558916
Ave neighs/atom = 139.72900
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 = 292.683951039128, Press = 0.900097683612731
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -22776.94    -22776.94   -22929.325   -22929.325    294.79891    294.79891    60595.301    60595.301    2159.3105    2159.3105 
   33000   -22774.624   -22774.624   -22927.736   -22927.736    296.20527    296.20527    60614.321    60614.321    1547.5502    1547.5502 
Loop time of 448.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.673 hours/ns, 2.228 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    | 447.65     | 447.65     | 447.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22441    | 0.22441    | 0.22441    |   0.0 |  0.05
Output  | 0.000177   | 0.000177   | 0.000177   |   0.0 |  0.00
Modify  | 0.83995    | 0.83995    | 0.83995    |   0.0 |  0.19
Other   |            | 0.1106     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 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:      558890.0 ave      558890 max      558890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558890
Ave neighs/atom = 139.72250
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 = 292.72246377405, Press = 0.0554457560833768
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -22774.624   -22774.624   -22927.736   -22927.736    296.20527    296.20527    60614.321    60614.321    1547.5502    1547.5502 
   34000   -22778.094   -22778.094   -22927.443   -22927.443    288.92634    288.92634    60662.938    60662.938   -730.10895   -730.10895 
Loop time of 440.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.444 hours/ns, 2.269 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    | 439.65     | 439.65     | 439.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21851    | 0.21851    | 0.21851    |   0.0 |  0.05
Output  | 0.00017945 | 0.00017945 | 0.00017945 |   0.0 |  0.00
Modify  | 0.81715    | 0.81715    | 0.81715    |   0.0 |  0.19
Other   |            | 0.1093     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8163.00 ave        8163 max        8163 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:      558764.0 ave      558764 max      558764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558764
Ave neighs/atom = 139.69100
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 = 292.800357883231, Press = -0.0276309515140687
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -22778.094   -22778.094   -22927.443   -22927.443    288.92634    288.92634    60662.938    60662.938   -730.10895   -730.10895 
   35000   -22784.262   -22784.262   -22930.284   -22930.284    282.48865    282.48865     60683.35     60683.35   -2106.3968   -2106.3968 
Loop time of 439.213 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 122.004 hours/ns, 2.277 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    | 438.04     | 438.04     | 438.04     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22209    | 0.22209    | 0.22209    |   0.0 |  0.05
Output  | 0.00023278 | 0.00023278 | 0.00023278 |   0.0 |  0.00
Modify  | 0.83678    | 0.83678    | 0.83678    |   0.0 |  0.19
Other   |            | 0.1117     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8140.00 ave        8140 max        8140 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:      558834.0 ave      558834 max      558834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558834
Ave neighs/atom = 139.70850
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 = 292.75821676557, Press = 0.513904235403839
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -22784.262   -22784.262   -22930.284   -22930.284    282.48865    282.48865     60683.35     60683.35   -2106.3968   -2106.3968 
   36000   -22776.904   -22776.904   -22930.094   -22930.094    296.35505    296.35505    60653.301    60653.301   -577.46268   -577.46268 
Loop time of 425.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.114 hours/ns, 2.352 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.11     | 424.11     | 424.11     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21404    | 0.21404    | 0.21404    |   0.0 |  0.05
Output  | 0.00017948 | 0.00017948 | 0.00017948 |   0.0 |  0.00
Modify  | 0.78252    | 0.78252    | 0.78252    |   0.0 |  0.18
Other   |            | 0.1059     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8163.00 ave        8163 max        8163 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:      558826.0 ave      558826 max      558826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558826
Ave neighs/atom = 139.70650
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 = 292.76399551863, Press = 1.2031789168691
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -22776.904   -22776.904   -22930.094   -22930.094    296.35505    296.35505    60653.301    60653.301   -577.46268   -577.46268 
   37000   -22777.366   -22777.366   -22928.577   -22928.577    292.52844    292.52844    60659.665    60659.665   -663.96617   -663.96617 
Loop time of 431.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.988 hours/ns, 2.315 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 430.84     | 430.84     | 430.84     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21521    | 0.21521    | 0.21521    |   0.0 |  0.05
Output  | 0.0001779  | 0.0001779  | 0.0001779  |   0.0 |  0.00
Modify  | 0.79495    | 0.79495    | 0.79495    |   0.0 |  0.18
Other   |            | 0.1075     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8157.00 ave        8157 max        8157 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:      558772.0 ave      558772 max      558772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558772
Ave neighs/atom = 139.69300
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 = 292.761624821184, Press = 0.768221483880871
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -22777.366   -22777.366   -22928.577   -22928.577    292.52844    292.52844    60659.665    60659.665   -663.96617   -663.96617 
   38000   -22780.171   -22780.171   -22930.668   -22930.668    291.14663    291.14663    60640.094    60640.094   -125.74954   -125.74954 
Loop time of 420.062 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 418.96     | 418.96     | 418.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21234    | 0.21234    | 0.21234    |   0.0 |  0.05
Output  | 0.0001764  | 0.0001764  | 0.0001764  |   0.0 |  0.00
Modify  | 0.78072    | 0.78072    | 0.78072    |   0.0 |  0.19
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:        8153.00 ave        8153 max        8153 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:      558732.0 ave      558732 max      558732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558732
Ave neighs/atom = 139.68300
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 = 292.803710183527, Press = 1.05177144871455
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -22780.171   -22780.171   -22930.668   -22930.668    291.14663    291.14663    60640.094    60640.094   -125.74954   -125.74954 
   39000    -22774.58    -22774.58   -22926.845   -22926.845    294.56694    294.56694    60606.788    60606.788    2010.7006    2010.7006 
Loop time of 429.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.200 hours/ns, 2.330 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    | 428.01     | 428.01     | 428.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21423    | 0.21423    | 0.21423    |   0.0 |  0.05
Output  | 0.00018649 | 0.00018649 | 0.00018649 |   0.0 |  0.00
Modify  | 0.79397    | 0.79397    | 0.79397    |   0.0 |  0.19
Other   |            | 0.1081     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8146.00 ave        8146 max        8146 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:      558778.0 ave      558778 max      558778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558778
Ave neighs/atom = 139.69450
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 = 292.817051679821, Press = 0.627204839492013
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -22774.58    -22774.58   -22926.845   -22926.845    294.56694    294.56694    60606.788    60606.788    2010.7006    2010.7006 
   40000   -22780.437   -22780.437    -22931.63    -22931.63    292.49432    292.49432    60583.457    60583.457    2453.1373    2453.1373 
Loop time of 448.24 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.511 hours/ns, 2.231 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    | 447.06     | 447.06     | 447.06     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22371    | 0.22371    | 0.22371    |   0.0 |  0.05
Output  | 0.00017772 | 0.00017772 | 0.00017772 |   0.0 |  0.00
Modify  | 0.84524    | 0.84524    | 0.84524    |   0.0 |  0.19
Other   |            | 0.1129     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8168.00 ave        8168 max        8168 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:      558828.0 ave      558828 max      558828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558828
Ave neighs/atom = 139.70700
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 = 292.874552402052, Press = 0.687601569955836
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -22780.437   -22780.437    -22931.63    -22931.63    292.49432    292.49432    60583.457    60583.457    2453.1373    2453.1373 
   41000   -22775.283   -22775.283   -22927.566   -22927.566    294.60072    294.60072    60647.083    60647.083    94.441275    94.441275 
Loop time of 402.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.853 hours/ns, 2.483 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    | 401.63     | 401.63     | 401.63     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20395    | 0.20395    | 0.20395    |   0.0 |  0.05
Output  | 0.00018794 | 0.00018794 | 0.00018794 |   0.0 |  0.00
Modify  | 0.73026    | 0.73026    | 0.73026    |   0.0 |  0.18
Other   |            | 0.1038     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8163.00 ave        8163 max        8163 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:      558950.0 ave      558950 max      558950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558950
Ave neighs/atom = 139.73750
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 = 292.850201628125, Press = 0.542902486759547
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -22775.283   -22775.283   -22927.566   -22927.566    294.60072    294.60072    60647.083    60647.083    94.441275    94.441275 
   42000   -22778.945   -22778.945   -22929.746   -22929.746     291.7358     291.7358     60623.42     60623.42    721.82987    721.82987 
Loop time of 399.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.077 hours/ns, 2.501 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    | 398.86     | 398.86     | 398.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20204    | 0.20204    | 0.20204    |   0.0 |  0.05
Output  | 0.00017647 | 0.00017647 | 0.00017647 |   0.0 |  0.00
Modify  | 0.71575    | 0.71575    | 0.71575    |   0.0 |  0.18
Other   |            | 0.103      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8174.00 ave        8174 max        8174 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:      558838.0 ave      558838 max      558838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558838
Ave neighs/atom = 139.70950
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 = 292.817304753897, Press = 1.00260767096457
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -22778.945   -22778.945   -22929.746   -22929.746     291.7358     291.7358     60623.42     60623.42    721.82987    721.82987 
   43000   -22771.612   -22771.612   -22925.199   -22925.199    297.12598    297.12598    60675.638    60675.638   -1063.9875   -1063.9875 
Loop time of 388.158 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.822 hours/ns, 2.576 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.17     | 387.17     | 387.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1972     | 0.1972     | 0.1972     |   0.0 |  0.05
Output  | 0.00018439 | 0.00018439 | 0.00018439 |   0.0 |  0.00
Modify  | 0.68617    | 0.68617    | 0.68617    |   0.0 |  0.18
Other   |            | 0.1001     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8179.00 ave        8179 max        8179 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:      558786.0 ave      558786 max      558786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558786
Ave neighs/atom = 139.69650
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 = 292.85281375868, Press = 2.27183393527761
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -22771.612   -22771.612   -22925.199   -22925.199    297.12598    297.12598    60675.638    60675.638   -1063.9875   -1063.9875 
   44000   -22779.702   -22779.702   -22930.533   -22930.533     291.7943     291.7943    60641.161    60641.161   -247.65531   -247.65531 
Loop time of 384.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.714 hours/ns, 2.603 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    | 383.2      | 383.2      | 383.2      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19661    | 0.19661    | 0.19661    |   0.0 |  0.05
Output  | 0.00017971 | 0.00017971 | 0.00017971 |   0.0 |  0.00
Modify  | 0.67215    | 0.67215    | 0.67215    |   0.0 |  0.17
Other   |            | 0.09923    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8151.00 ave        8151 max        8151 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:      558710.0 ave      558710 max      558710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558710
Ave neighs/atom = 139.67750
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 = 292.88670637543, Press = 1.3426068308925
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -22779.702   -22779.702   -22930.533   -22930.533     291.7943     291.7943    60641.161    60641.161   -247.65531   -247.65531 
   45000   -22777.501   -22777.501    -22928.01    -22928.01    291.16909    291.16909    60674.481    60674.481   -1423.4559   -1423.4559 
Loop time of 400.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.132 hours/ns, 2.500 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 399.06     | 399.06     | 399.06     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20245    | 0.20245    | 0.20245    |   0.0 |  0.05
Output  | 0.00018365 | 0.00018365 | 0.00018365 |   0.0 |  0.00
Modify  | 0.71506    | 0.71506    | 0.71506    |   0.0 |  0.18
Other   |            | 0.1018     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8173.00 ave        8173 max        8173 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:      558758.0 ave      558758 max      558758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558758
Ave neighs/atom = 139.68950
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 = 292.871096346434, Press = 1.02803976051563
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -22777.501   -22777.501    -22928.01    -22928.01    291.16909    291.16909    60674.481    60674.481   -1423.4559   -1423.4559 
   46000   -22774.901   -22774.901   -22927.724   -22927.724    295.64758    295.64758    60585.336    60585.336    2951.3255    2951.3255 
Loop time of 420.029 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.675 hours/ns, 2.381 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    | 418.95     | 418.95     | 418.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20996    | 0.20996    | 0.20996    |   0.0 |  0.05
Output  | 0.00017822 | 0.00017822 | 0.00017822 |   0.0 |  0.00
Modify  | 0.76655    | 0.76655    | 0.76655    |   0.0 |  0.18
Other   |            | 0.1064     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8158.00 ave        8158 max        8158 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:      558684.0 ave      558684 max      558684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558684
Ave neighs/atom = 139.67100
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 = 292.843340366802, Press = 0.773874742501598
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -22774.901   -22774.901   -22927.724   -22927.724    295.64758    295.64758    60585.336    60585.336    2951.3255    2951.3255 
   47000   -22778.995   -22778.995   -22931.524   -22931.524    295.07772    295.07772    60575.159    60575.159    2795.0227    2795.0227 
Loop time of 393.782 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.384 hours/ns, 2.539 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    | 392.77     | 392.77     | 392.77     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19942    | 0.19942    | 0.19942    |   0.0 |  0.05
Output  | 0.00017648 | 0.00017648 | 0.00017648 |   0.0 |  0.00
Modify  | 0.70935    | 0.70935    | 0.70935    |   0.0 |  0.18
Other   |            | 0.1024     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8164.00 ave        8164 max        8164 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:      558880.0 ave      558880 max      558880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558880
Ave neighs/atom = 139.72000
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 = 292.859486418103, Press = 0.464737246518722
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -22778.995   -22778.995   -22931.524   -22931.524    295.07772    295.07772    60575.159    60575.159    2795.0227    2795.0227 
   48000   -22773.267   -22773.267   -22926.258   -22926.258    295.97167    295.97167     60662.67     60662.67   -592.94299   -592.94299 
Loop time of 397.796 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.499 hours/ns, 2.514 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    | 396.78     | 396.78     | 396.78     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2006     | 0.2006     | 0.2006     |   0.0 |  0.05
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.71099    | 0.71099    | 0.71099    |   0.0 |  0.18
Other   |            | 0.1033     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8167.00 ave        8167 max        8167 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:      558922.0 ave      558922 max      558922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558922
Ave neighs/atom = 139.73050
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 = 292.908459339551, Press = 0.524567743543016
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -22773.267   -22773.267   -22926.258   -22926.258    295.97167    295.97167     60662.67     60662.67   -592.94299   -592.94299 
   49000   -22777.262   -22777.262   -22928.196   -22928.196    291.99142    291.99142     60702.46     60702.46   -2677.3732   -2677.3732 
Loop time of 380.493 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.692 hours/ns, 2.628 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 379.53     | 379.53     | 379.53     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19086    | 0.19086    | 0.19086    |   0.0 |  0.05
Output  | 0.0002278  | 0.0002278  | 0.0002278  |   0.0 |  0.00
Modify  | 0.67038    | 0.67038    | 0.67038    |   0.0 |  0.18
Other   |            | 0.1017     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558802.0 ave      558802 max      558802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558802
Ave neighs/atom = 139.70050
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 = 292.936891147399, Press = -0.317812574573228
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -22777.262   -22777.262   -22928.196   -22928.196    291.99142    291.99142     60702.46     60702.46   -2677.3732   -2677.3732 
   50000   -22777.569   -22777.569   -22928.516   -22928.516    292.01725    292.01725    60691.249    60691.249   -2138.3589   -2138.3589 
Loop time of 379.526 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.424 hours/ns, 2.635 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    | 378.57     | 378.57     | 378.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19133    | 0.19133    | 0.19133    |   0.0 |  0.05
Output  | 0.00018254 | 0.00018254 | 0.00018254 |   0.0 |  0.00
Modify  | 0.66628    | 0.66628    | 0.66628    |   0.0 |  0.18
Other   |            | 0.09975    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8162.00 ave        8162 max        8162 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:      558778.0 ave      558778 max      558778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558778
Ave neighs/atom = 139.69450
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 = 292.953230785336, Press = 0.849345369660904
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -22777.569   -22777.569   -22928.516   -22928.516    292.01725    292.01725    60691.249    60691.249   -2138.3589   -2138.3589 
   51000   -22775.648   -22775.648   -22928.961   -22928.961    296.59529    296.59529    60652.401    60652.401   -438.83209   -438.83209 
Loop time of 379.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.309 hours/ns, 2.638 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    | 378.16     | 378.16     | 378.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18915    | 0.18915    | 0.18915    |   0.0 |  0.05
Output  | 0.00017913 | 0.00017913 | 0.00017913 |   0.0 |  0.00
Modify  | 0.66605    | 0.66605    | 0.66605    |   0.0 |  0.18
Other   |            | 0.09987    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8152.00 ave        8152 max        8152 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:      558708.0 ave      558708 max      558708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558708
Ave neighs/atom = 139.67700
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 = 292.946933718765, Press = 0.44851434052786
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -22775.648   -22775.648   -22928.961   -22928.961    296.59529    296.59529    60652.401    60652.401   -438.83209   -438.83209 
   52000   -22782.702   -22782.702    -22930.46    -22930.46    285.84793    285.84793    60625.161    60625.161    551.97006    551.97006 
Loop time of 381.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.065 hours/ns, 2.619 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    | 380.87     | 380.87     | 380.87     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19365    | 0.19365    | 0.19365    |   0.0 |  0.05
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.66973    | 0.66973    | 0.66973    |   0.0 |  0.18
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:        8175.00 ave        8175 max        8175 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:      558812.0 ave      558812 max      558812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558812
Ave neighs/atom = 139.70300
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 = 292.941321311433, Press = 0.838761880540433
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -22782.702   -22782.702    -22930.46    -22930.46    285.84793    285.84793    60625.161    60625.161    551.97006    551.97006 
   53000   -22776.278   -22776.278   -22927.044   -22927.044    291.66739    291.66739    60616.457    60616.457    1434.3893    1434.3893 
Loop time of 406.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.929 hours/ns, 2.460 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    | 405.51     | 405.51     | 405.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20224    | 0.20224    | 0.20224    |   0.0 |  0.05
Output  | 0.0002285  | 0.0002285  | 0.0002285  |   0.0 |  0.00
Modify  | 0.72973    | 0.72973    | 0.72973    |   0.0 |  0.18
Other   |            | 0.1037     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8176.00 ave        8176 max        8176 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:      558900.0 ave      558900 max      558900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558900
Ave neighs/atom = 139.72500
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 = 292.916377934253, Press = 0.639571155718465
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -22776.278   -22776.278   -22927.044   -22927.044    291.66739    291.66739    60616.457    60616.457    1434.3893    1434.3893 
   54000   -22782.159   -22782.159   -22932.192   -22932.192    290.24816    290.24816    60651.434    60651.434    -992.1322    -992.1322 
Loop time of 447.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.200 hours/ns, 2.237 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    | 445.95     | 445.95     | 445.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21951    | 0.21951    | 0.21951    |   0.0 |  0.05
Output  | 0.00022505 | 0.00022505 | 0.00022505 |   0.0 |  0.00
Modify  | 0.84222    | 0.84222    | 0.84222    |   0.0 |  0.19
Other   |            | 0.1109     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 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:      558792.0 ave      558792 max      558792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558792
Ave neighs/atom = 139.69800
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 = 292.895767230001, Press = 0.179964481438253
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -22782.159   -22782.159   -22932.192   -22932.192    290.24816    290.24816    60651.434    60651.434    -992.1322    -992.1322 
   55000   -22780.147   -22780.147   -22930.097   -22930.097    290.08998    290.08998    60616.271    60616.271     1016.522     1016.522 
Loop time of 416.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.767 hours/ns, 2.399 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 415.69     | 415.69     | 415.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20726    | 0.20726    | 0.20726    |   0.0 |  0.05
Output  | 0.00018032 | 0.00018032 | 0.00018032 |   0.0 |  0.00
Modify  | 0.76132    | 0.76132    | 0.76132    |   0.0 |  0.18
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:        8170.00 ave        8170 max        8170 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:      558850.0 ave      558850 max      558850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558850
Ave neighs/atom = 139.71250
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 = 292.909179835862, Press = 1.14740816464704
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -22780.147   -22780.147   -22930.097   -22930.097    290.08998    290.08998    60616.271    60616.271     1016.522     1016.522 
   56000   -22773.871   -22773.871   -22925.508   -22925.508    293.35163    293.35163    60629.828    60629.828    1087.4934    1087.4934 
Loop time of 435.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 120.953 hours/ns, 2.297 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    | 434.3      | 434.3      | 434.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21469    | 0.21469    | 0.21469    |   0.0 |  0.05
Output  | 0.00018161 | 0.00018161 | 0.00018161 |   0.0 |  0.00
Modify  | 0.80795    | 0.80795    | 0.80795    |   0.0 |  0.19
Other   |            | 0.111      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 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:      558864.0 ave      558864 max      558864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558864
Ave neighs/atom = 139.71600
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 = 292.924557387285, Press = 1.57732923990035
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -22773.871   -22773.871   -22925.508   -22925.508    293.35163    293.35163    60629.828    60629.828    1087.4934    1087.4934 
   57000    -22779.64    -22779.64   -22930.493   -22930.493    291.83603    291.83603     60632.34     60632.34    261.87858    261.87858 
Loop time of 425.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.262 hours/ns, 2.349 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 424.65     | 424.65     | 424.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21262    | 0.21262    | 0.21262    |   0.0 |  0.05
Output  | 0.00017887 | 0.00017887 | 0.00017887 |   0.0 |  0.00
Modify  | 0.77017    | 0.77017    | 0.77017    |   0.0 |  0.18
Other   |            | 0.1075     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 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:      558820.0 ave      558820 max      558820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558820
Ave neighs/atom = 139.70500
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
60641.6357501866

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0