# 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 4.049985826015473*${_u_distance}
variable latticeconst_converted equal 4.049985826015473*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04998582601547
Lattice spacing in x,y,z = 4.0499858 4.0499858 4.0499858
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 (40.499858 40.499858 40.499858)
  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 (40.499858 40.499858 40.499858)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_SunRamachandranWick_2018_TiAl__MO_022920256108_001
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.143 | 4.143 | 4.143 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13250.675   -13250.675   -13412.545   -13412.545       313.15       313.15    66429.428    66429.428    2602.7049    2602.7049 
    1000   -13072.733   -13072.733    -13237.93    -13237.93    319.58596    319.58596    67559.489    67559.489   -500.75387   -500.75387 
Loop time of 224.445 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.346 hours/ns, 4.455 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    | 223.55     | 223.55     | 223.55     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10876    | 0.10876    | 0.10876    |   0.0 |  0.05
Output  | 0.00026894 | 0.00026894 | 0.00026894 |   0.0 |  0.00
Modify  | 0.69239    | 0.69239    | 0.69239    |   0.0 |  0.31
Other   |            | 0.09543    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3813.00 ave        3813 max        3813 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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 216000
Ave neighs/atom = 54.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13072.733   -13072.733    -13237.93    -13237.93    319.58596    319.58596    67559.489    67559.489   -500.75387   -500.75387 
    2000   -13088.355   -13088.355   -13246.758   -13246.758    306.44079    306.44079    67478.955    67478.955   -267.70877   -267.70877 
Loop time of 235.154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.321 hours/ns, 4.253 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    | 234.26     | 234.26     | 234.26     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11247    | 0.11247    | 0.11247    |   0.0 |  0.05
Output  | 0.00033265 | 0.00033265 | 0.00033265 |   0.0 |  0.00
Modify  | 0.68265    | 0.68265    | 0.68265    |   0.0 |  0.29
Other   |            | 0.09484    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4068.00 ave        4068 max        4068 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:      214472.0 ave      214472 max      214472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214472
Ave neighs/atom = 53.618000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13088.355   -13088.355   -13246.758   -13246.758    306.44079    306.44079    67478.955    67478.955   -267.70877   -267.70877 
    3000   -13081.364   -13081.364   -13241.725   -13241.725    310.22911    310.22911    67434.618    67434.618    397.50392    397.50392 
Loop time of 235.32 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.367 hours/ns, 4.250 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    | 234.43     | 234.43     | 234.43     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10943    | 0.10943    | 0.10943    |   0.0 |  0.05
Output  | 0.00022126 | 0.00022126 | 0.00022126 |   0.0 |  0.00
Modify  | 0.68126    | 0.68126    | 0.68126    |   0.0 |  0.29
Other   |            | 0.09485    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4039.00 ave        4039 max        4039 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:      214790.0 ave      214790 max      214790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214790
Ave neighs/atom = 53.697500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13081.364   -13081.364   -13241.725   -13241.725    310.22911    310.22911    67434.618    67434.618    397.50392    397.50392 
    4000   -13082.961   -13082.961   -13245.111   -13245.111    313.69073    313.69073     67479.68     67479.68   -141.59734   -141.59734 
Loop time of 233.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.860 hours/ns, 4.283 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    | 232.61     | 232.61     | 232.61     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1116     | 0.1116     | 0.1116     |   0.0 |  0.05
Output  | 0.00026243 | 0.00026243 | 0.00026243 |   0.0 |  0.00
Modify  | 0.67625    | 0.67625    | 0.67625    |   0.0 |  0.29
Other   |            | 0.09577    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4085.00 ave        4085 max        4085 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:      214764.0 ave      214764 max      214764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214764
Ave neighs/atom = 53.691000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13082.961   -13082.961   -13245.111   -13245.111    313.69073    313.69073     67479.68     67479.68   -141.59734   -141.59734 
    5000   -13084.955   -13084.955   -13238.811   -13238.811    297.64576    297.64576    67506.688    67506.688   -245.84897   -245.84897 
Loop time of 234.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.270 hours/ns, 4.256 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    | 234.07     | 234.07     | 234.07     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10979    | 0.10979    | 0.10979    |   0.0 |  0.05
Output  | 0.00022392 | 0.00022392 | 0.00022392 |   0.0 |  0.00
Modify  | 0.69285    | 0.69285    | 0.69285    |   0.0 |  0.29
Other   |            | 0.09668    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4026.00 ave        4026 max        4026 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:      214670.0 ave      214670 max      214670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214670
Ave neighs/atom = 53.667500
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 = 311.7524045828, Press = -293.833288454195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13084.955   -13084.955   -13238.811   -13238.811    297.64576    297.64576    67506.688    67506.688   -245.84897   -245.84897 
    6000    -13082.13    -13082.13   -13244.798   -13244.798    314.69137    314.69137    67373.747    67373.747    866.40558    866.40558 
Loop time of 231.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.361 hours/ns, 4.316 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    | 230.8      | 230.8      | 230.8      |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11006    | 0.11006    | 0.11006    |   0.0 |  0.05
Output  | 0.00017951 | 0.00017951 | 0.00017951 |   0.0 |  0.00
Modify  | 0.68961    | 0.68961    | 0.68961    |   0.0 |  0.30
Other   |            | 0.09453    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4093.00 ave        4093 max        4093 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:      214578.0 ave      214578 max      214578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214578
Ave neighs/atom = 53.644500
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 = 312.626340443452, Press = -30.9211724557425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -13082.13    -13082.13   -13244.798   -13244.798    314.69137    314.69137    67373.747    67373.747    866.40558    866.40558 
    7000   -13083.991   -13083.991   -13245.444   -13245.444    312.34158    312.34158    67443.449    67443.449     228.7705     228.7705 
Loop time of 231.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.251 hours/ns, 4.323 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    | 230.41     | 230.41     | 230.41     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10948    | 0.10948    | 0.10948    |   0.0 |  0.05
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.6894     | 0.6894     | 0.6894     |   0.0 |  0.30
Other   |            | 0.09413    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4059.00 ave        4059 max        4059 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:      214866.0 ave      214866 max      214866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214866
Ave neighs/atom = 53.716500
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 = 313.123240719442, Press = 17.5687489653157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13083.991   -13083.991   -13245.444   -13245.444    312.34158    312.34158    67443.449    67443.449     228.7705     228.7705 
    8000   -13081.716   -13081.716   -13244.973   -13244.973    315.83223    315.83223    67571.102    67571.102   -938.36259   -938.36259 
Loop time of 238.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.362 ns/day, 66.330 hours/ns, 4.188 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    | 237.85     | 237.85     | 237.85     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11403    | 0.11403    | 0.11403    |   0.0 |  0.05
Output  | 0.00018224 | 0.00018224 | 0.00018224 |   0.0 |  0.00
Modify  | 0.72787    | 0.72787    | 0.72787    |   0.0 |  0.30
Other   |            | 0.09635    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4064.00 ave        4064 max        4064 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:      214726.0 ave      214726 max      214726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214726
Ave neighs/atom = 53.681500
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 = 312.722287718225, Press = -7.14535479035452
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13081.716   -13081.716   -13244.973   -13244.973    315.83223    315.83223    67571.102    67571.102   -938.36259   -938.36259 
    9000   -13089.184   -13089.184   -13248.377   -13248.377     307.9696     307.9696    67407.155    67407.155    336.88738    336.88738 
Loop time of 232.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.371 ns/day, 64.656 hours/ns, 4.296 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    | 231.86     | 231.86     | 231.86     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10985    | 0.10985    | 0.10985    |   0.0 |  0.05
Output  | 0.00028743 | 0.00028743 | 0.00028743 |   0.0 |  0.00
Modify  | 0.69494    | 0.69494    | 0.69494    |   0.0 |  0.30
Other   |            | 0.09482    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4074.00 ave        4074 max        4074 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:      214658.0 ave      214658 max      214658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214658
Ave neighs/atom = 53.664500
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 = 312.5589724399, Press = -6.85191788262843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13089.184   -13089.184   -13248.377   -13248.377     307.9696     307.9696    67407.155    67407.155    336.88738    336.88738 
   10000    -13082.47    -13082.47   -13246.093   -13246.093    316.54064    316.54064    67442.851    67442.851    181.25826    181.25826 
Loop time of 235.407 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.391 hours/ns, 4.248 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    | 234.49     | 234.49     | 234.49     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11195    | 0.11195    | 0.11195    |   0.0 |  0.05
Output  | 0.00018063 | 0.00018063 | 0.00018063 |   0.0 |  0.00
Modify  | 0.71084    | 0.71084    | 0.71084    |   0.0 |  0.30
Other   |            | 0.0977     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4054.00 ave        4054 max        4054 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:      214820.0 ave      214820 max      214820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214820
Ave neighs/atom = 53.705000
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 = 312.490024201213, Press = 0.223724077863876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -13082.47    -13082.47   -13246.093   -13246.093    316.54064    316.54064    67442.851    67442.851    181.25826    181.25826 
   11000   -13091.109   -13091.109   -13249.506   -13249.506    306.42903    306.42903    67495.127    67495.127   -532.88515   -532.88515 
Loop time of 235.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.464 hours/ns, 4.243 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    | 234.75     | 234.75     | 234.75     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11289    | 0.11289    | 0.11289    |   0.0 |  0.05
Output  | 0.00023103 | 0.00023103 | 0.00023103 |   0.0 |  0.00
Modify  | 0.71585    | 0.71585    | 0.71585    |   0.0 |  0.30
Other   |            | 0.09559    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 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:      214782.0 ave      214782 max      214782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214782
Ave neighs/atom = 53.695500
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 = 312.221593092349, Press = -2.37117346811899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13091.109   -13091.109   -13249.506   -13249.506    306.42903    306.42903    67495.127    67495.127   -532.88515   -532.88515 
   12000   -13083.294   -13083.294   -13244.873   -13244.873    312.58563    312.58563    67425.945    67425.945    390.83446    390.83446 
Loop time of 234.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.260 hours/ns, 4.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    | 234.02     | 234.02     | 234.02     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11115    | 0.11115    | 0.11115    |   0.0 |  0.05
Output  | 0.00018116 | 0.00018116 | 0.00018116 |   0.0 |  0.00
Modify  | 0.70765    | 0.70765    | 0.70765    |   0.0 |  0.30
Other   |            | 0.09556    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4012.00 ave        4012 max        4012 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:      214762.0 ave      214762 max      214762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214762
Ave neighs/atom = 53.690500
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 = 312.272459127041, Press = -4.83118589980268
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13083.294   -13083.294   -13244.873   -13244.873    312.58563    312.58563    67425.945    67425.945    390.83446    390.83446 
   13000   -13076.059   -13076.059   -13239.788   -13239.788    316.74484    316.74484    67432.563    67432.563    526.12984    526.12984 
Loop time of 231.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.346 hours/ns, 4.317 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    | 230.74     | 230.74     | 230.74     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11126    | 0.11126    | 0.11126    |   0.0 |  0.05
Output  | 0.00017797 | 0.00017797 | 0.00017797 |   0.0 |  0.00
Modify  | 0.69446    | 0.69446    | 0.69446    |   0.0 |  0.30
Other   |            | 0.09475    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4077.00 ave        4077 max        4077 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:      214736.0 ave      214736 max      214736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214736
Ave neighs/atom = 53.684000
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 = 312.400289134197, Press = 1.72745334135208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13076.059   -13076.059   -13239.788   -13239.788    316.74484    316.74484    67432.563    67432.563    526.12984    526.12984 
   14000   -13085.212   -13085.212    -13246.16    -13246.16    311.36407    311.36407    67579.545    67579.545   -1109.0701   -1109.0701 
Loop time of 241.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.358 ns/day, 66.994 hours/ns, 4.146 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    | 240.23     | 240.23     | 240.23     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11497    | 0.11497    | 0.11497    |   0.0 |  0.05
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.73715    | 0.73715    | 0.73715    |   0.0 |  0.31
Other   |            | 0.09697    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4065.00 ave        4065 max        4065 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:      214658.0 ave      214658 max      214658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214658
Ave neighs/atom = 53.664500
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 = 312.677820629977, Press = -1.3331717067238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13085.212   -13085.212    -13246.16    -13246.16    311.36407    311.36407    67579.545    67579.545   -1109.0701   -1109.0701 
   15000    -13078.72    -13078.72   -13242.092   -13242.092    316.05432    316.05432    67465.277    67465.277    168.07152    168.07152 
Loop time of 236.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.741 hours/ns, 4.225 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    | 235.75     | 235.75     | 235.75     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.113      | 0.113      | 0.113      |   0.0 |  0.05
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.71197    | 0.71197    | 0.71197    |   0.0 |  0.30
Other   |            | 0.09572    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4069.00 ave        4069 max        4069 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:      214772.0 ave      214772 max      214772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214772
Ave neighs/atom = 53.693000
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 = 312.847071718938, Press = -5.19232288616178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -13078.72    -13078.72   -13242.092   -13242.092    316.05432    316.05432    67465.277    67465.277    168.07152    168.07152 
   16000    -13083.39    -13083.39   -13245.666   -13245.666    313.93303    313.93303    67425.915    67425.915    345.09504    345.09504 
Loop time of 234.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.368 ns/day, 65.166 hours/ns, 4.263 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    | 233.68     | 233.68     | 233.68     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11196    | 0.11196    | 0.11196    |   0.0 |  0.05
Output  | 0.00030919 | 0.00030919 | 0.00030919 |   0.0 |  0.00
Modify  | 0.70486    | 0.70486    | 0.70486    |   0.0 |  0.30
Other   |            | 0.09571    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4069.00 ave        4069 max        4069 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:      214696.0 ave      214696 max      214696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214696
Ave neighs/atom = 53.674000
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 = 312.78097086539, Press = -0.569232831540483
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -13083.39    -13083.39   -13245.666   -13245.666    313.93303    313.93303    67425.915    67425.915    345.09504    345.09504 
   17000   -13082.112   -13082.112   -13244.403   -13244.403    313.96402    313.96402     67504.17     67504.17   -327.44126   -327.44126 
Loop time of 233.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.929 hours/ns, 4.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    | 232.84     | 232.84     | 232.84     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11033    | 0.11033    | 0.11033    |   0.0 |  0.05
Output  | 0.0002208  | 0.0002208  | 0.0002208  |   0.0 |  0.00
Modify  | 0.70162    | 0.70162    | 0.70162    |   0.0 |  0.30
Other   |            | 0.0949     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4046.00 ave        4046 max        4046 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:      214834.0 ave      214834 max      214834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214834
Ave neighs/atom = 53.708500
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 = 312.752681486442, Press = -0.858912529498765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13082.112   -13082.112   -13244.403   -13244.403    313.96402    313.96402     67504.17     67504.17   -327.44126   -327.44126 
   18000   -13083.412   -13083.412   -13243.688   -13243.688    310.06451    310.06451    67464.811    67464.811   -3.3066794   -3.3066794 
Loop time of 236.065 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.574 hours/ns, 4.236 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    | 235.14     | 235.14     | 235.14     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11172    | 0.11172    | 0.11172    |   0.0 |  0.05
Output  | 0.00022127 | 0.00022127 | 0.00022127 |   0.0 |  0.00
Modify  | 0.71279    | 0.71279    | 0.71279    |   0.0 |  0.30
Other   |            | 0.09594    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4047.00 ave        4047 max        4047 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:      214704.0 ave      214704 max      214704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214704
Ave neighs/atom = 53.676000
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 = 312.74245576097, Press = -2.40471663823334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13083.412   -13083.412   -13243.688   -13243.688    310.06451    310.06451    67464.811    67464.811   -3.3066794   -3.3066794 
   19000   -13089.858   -13089.858   -13248.361   -13248.361    306.63484    306.63484    67368.665    67368.665    739.96911    739.96911 
Loop time of 236.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.809 hours/ns, 4.221 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    | 235.99     | 235.99     | 235.99     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11249    | 0.11249    | 0.11249    |   0.0 |  0.05
Output  | 0.00017877 | 0.00017877 | 0.00017877 |   0.0 |  0.00
Modify  | 0.71794    | 0.71794    | 0.71794    |   0.0 |  0.30
Other   |            | 0.09584    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4060.00 ave        4060 max        4060 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:      214776.0 ave      214776 max      214776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214776
Ave neighs/atom = 53.694000
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 = 312.700821074212, Press = -0.504760303647226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13089.858   -13089.858   -13248.361   -13248.361    306.63484    306.63484    67368.665    67368.665    739.96911    739.96911 
   20000   -13080.305   -13080.305   -13239.934   -13239.934     308.8123     308.8123    67582.319    67582.319   -881.59813   -881.59813 
Loop time of 233.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.854 hours/ns, 4.283 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    | 232.57     | 232.57     | 232.57     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11073    | 0.11073    | 0.11073    |   0.0 |  0.05
Output  | 0.00018167 | 0.00018167 | 0.00018167 |   0.0 |  0.00
Modify  | 0.70345    | 0.70345    | 0.70345    |   0.0 |  0.30
Other   |            | 0.09553    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4073.00 ave        4073 max        4073 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:      214880.0 ave      214880 max      214880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214880
Ave neighs/atom = 53.720000
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 = 312.64747181369, Press = 0.854149986560974
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13080.305   -13080.305   -13239.934   -13239.934     308.8123     308.8123    67582.319    67582.319   -881.59813   -881.59813 
   21000   -13083.529   -13083.529   -13246.626   -13246.626    315.52298    315.52298    67501.591    67501.591   -368.87599   -368.87599 
Loop time of 233.513 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.865 hours/ns, 4.282 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    | 232.61     | 232.61     | 232.61     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11201    | 0.11201    | 0.11201    |   0.0 |  0.05
Output  | 0.0002272  | 0.0002272  | 0.0002272  |   0.0 |  0.00
Modify  | 0.69624    | 0.69624    | 0.69624    |   0.0 |  0.30
Other   |            | 0.09514    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      214596.0 ave      214596 max      214596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214596
Ave neighs/atom = 53.649000
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 = 312.694881986643, Press = -3.40434843193113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13083.529   -13083.529   -13246.626   -13246.626    315.52298    315.52298    67501.591    67501.591   -368.87599   -368.87599 
   22000   -13083.295   -13083.295   -13244.824   -13244.824    312.48773    312.48773    67398.896    67398.896    627.11084    627.11084 
Loop time of 233.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.907 hours/ns, 4.280 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    | 232.76     | 232.76     | 232.76     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11007    | 0.11007    | 0.11007    |   0.0 |  0.05
Output  | 0.00017795 | 0.00017795 | 0.00017795 |   0.0 |  0.00
Modify  | 0.69938    | 0.69938    | 0.69938    |   0.0 |  0.30
Other   |            | 0.09525    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 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:      214768.0 ave      214768 max      214768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214768
Ave neighs/atom = 53.692000
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 = 312.742528173297, Press = -0.638934994693711
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13083.295   -13083.295   -13244.824   -13244.824    312.48773    312.48773    67398.896    67398.896    627.11084    627.11084 
   23000    -13083.98    -13083.98   -13247.196   -13247.196    315.75239    315.75239    67483.094    67483.094   -213.66033   -213.66033 
Loop time of 233.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.914 hours/ns, 4.279 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    | 232.78     | 232.78     | 232.78     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11131    | 0.11131    | 0.11131    |   0.0 |  0.05
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.70439    | 0.70439    | 0.70439    |   0.0 |  0.30
Other   |            | 0.09482    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4075.00 ave        4075 max        4075 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:      214794.0 ave      214794 max      214794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214794
Ave neighs/atom = 53.698500
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 = 312.664222881837, Press = 0.0339189342097113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000    -13083.98    -13083.98   -13247.196   -13247.196    315.75239    315.75239    67483.094    67483.094   -213.66033   -213.66033 
   24000   -13085.432   -13085.432   -13248.155   -13248.155    314.79841    314.79841    67477.072    67477.072   -244.40508   -244.40508 
Loop time of 232.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.371 ns/day, 64.671 hours/ns, 4.295 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    | 231.92     | 231.92     | 231.92     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10973    | 0.10973    | 0.10973    |   0.0 |  0.05
Output  | 0.00017953 | 0.00017953 | 0.00017953 |   0.0 |  0.00
Modify  | 0.69018    | 0.69018    | 0.69018    |   0.0 |  0.30
Other   |            | 0.09448    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4003.00 ave        4003 max        4003 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:      214844.0 ave      214844 max      214844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214844
Ave neighs/atom = 53.711000
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 = 312.706166731797, Press = -1.27537459626782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13085.432   -13085.432   -13248.155   -13248.155    314.79841    314.79841    67477.072    67477.072   -244.40508   -244.40508 
   25000   -13081.488   -13081.488   -13241.786   -13241.786    310.10728    310.10728    67457.811    67457.811    150.85728    150.85728 
Loop time of 233.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.790 hours/ns, 4.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    | 232.35     | 232.35     | 232.35     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11028    | 0.11028    | 0.11028    |   0.0 |  0.05
Output  | 0.00017975 | 0.00017975 | 0.00017975 |   0.0 |  0.00
Modify  | 0.69518    | 0.69518    | 0.69518    |   0.0 |  0.30
Other   |            | 0.09465    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4068.00 ave        4068 max        4068 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:      214738.0 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.684500
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 = 312.684974448197, Press = -0.990733473215337
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13081.488   -13081.488   -13241.786   -13241.786    310.10728    310.10728    67457.811    67457.811    150.85728    150.85728 
   26000   -13089.191   -13089.191   -13245.991   -13245.991    303.33855    303.33855    67435.258    67435.258    163.17728    163.17728 
Loop time of 232.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.371 ns/day, 64.690 hours/ns, 4.294 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    | 231.98     | 231.98     | 231.98     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.05
Output  | 0.00018094 | 0.00018094 | 0.00018094 |   0.0 |  0.00
Modify  | 0.69425    | 0.69425    | 0.69425    |   0.0 |  0.30
Other   |            | 0.0948     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4069.00 ave        4069 max        4069 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:      214742.0 ave      214742 max      214742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214742
Ave neighs/atom = 53.685500
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 = 312.63174172548, Press = -0.826406754427011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13089.191   -13089.191   -13245.991   -13245.991    303.33855    303.33855    67435.258    67435.258    163.17728    163.17728 
   27000   -13081.273   -13081.273   -13245.461   -13245.461    317.63226    317.63226    67457.215    67457.215    59.219768    59.219768 
Loop time of 235.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.366 ns/day, 65.507 hours/ns, 4.240 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    | 234.91     | 234.91     | 234.91     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11268    | 0.11268    | 0.11268    |   0.0 |  0.05
Output  | 0.00017876 | 0.00017876 | 0.00017876 |   0.0 |  0.00
Modify  | 0.71137    | 0.71137    | 0.71137    |   0.0 |  0.30
Other   |            | 0.09569    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4072.00 ave        4072 max        4072 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:      214766.0 ave      214766 max      214766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214766
Ave neighs/atom = 53.691500
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 = 312.607607883966, Press = -0.928665677609717
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13081.273   -13081.273   -13245.461   -13245.461    317.63226    317.63226    67457.215    67457.215    59.219768    59.219768 
   28000   -13086.917   -13086.917    -13248.84    -13248.84    313.25127    313.25127    67454.799    67454.799   -57.032352   -57.032352 
Loop time of 233.683 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.370 ns/day, 64.912 hours/ns, 4.279 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    | 232.77     | 232.77     | 232.77     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1113     | 0.1113     | 0.1113     |   0.0 |  0.05
Output  | 0.00028729 | 0.00028729 | 0.00028729 |   0.0 |  0.00
Modify  | 0.70742    | 0.70742    | 0.70742    |   0.0 |  0.30
Other   |            | 0.09545    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4105.00 ave        4105 max        4105 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:      214752.0 ave      214752 max      214752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214752
Ave neighs/atom = 53.688000
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 = 312.55548722652, Press = -0.207668270766645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13086.917   -13086.917    -13248.84    -13248.84    313.25127    313.25127    67454.799    67454.799   -57.032352   -57.032352 
   29000    -13081.71    -13081.71   -13244.915   -13244.915    315.73168    315.73168    67526.826    67526.826   -547.18094   -547.18094 
Loop time of 230.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.116 hours/ns, 4.332 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    | 229.92     | 229.92     | 229.92     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10937    | 0.10937    | 0.10937    |   0.0 |  0.05
Output  | 0.00018025 | 0.00018025 | 0.00018025 |   0.0 |  0.00
Modify  | 0.69019    | 0.69019    | 0.69019    |   0.0 |  0.30
Other   |            | 0.09449    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4086.00 ave        4086 max        4086 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:      214760.0 ave      214760 max      214760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214760
Ave neighs/atom = 53.690000
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 = 312.57019234657, Press = -1.51662536494218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -13081.71    -13081.71   -13244.915   -13244.915    315.73168    315.73168    67526.826    67526.826   -547.18094   -547.18094 
   30000    -13082.31    -13082.31   -13244.239   -13244.239     313.2631     313.2631     67369.04     67369.04    962.95787    962.95787 
Loop time of 235.425 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.367 ns/day, 65.396 hours/ns, 4.248 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    | 234.51     | 234.51     | 234.51     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11027    | 0.11027    | 0.11027    |   0.0 |  0.05
Output  | 0.00044797 | 0.00044797 | 0.00044797 |   0.0 |  0.00
Modify  | 0.70711    | 0.70711    | 0.70711    |   0.0 |  0.30
Other   |            | 0.09562    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4056.00 ave        4056 max        4056 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:      214684.0 ave      214684 max      214684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214684
Ave neighs/atom = 53.671000
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 = 312.596680038497, Press = -1.44085868014693
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.146 | 4.146 | 4.146 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -13082.31    -13082.31   -13244.239   -13244.239     313.2631     313.2631     67369.04     67369.04    962.95787    962.95787 
   31000   -13077.901   -13077.901   -13241.484   -13241.484    316.46187    316.46187    67471.526    67471.526    147.86135    147.86135 
Loop time of 234.375 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.104 hours/ns, 4.267 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    | 233.47     | 233.47     | 233.47     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11057    | 0.11057    | 0.11057    |   0.0 |  0.05
Output  | 0.00017898 | 0.00017898 | 0.00017898 |   0.0 |  0.00
Modify  | 0.70214    | 0.70214    | 0.70214    |   0.0 |  0.30
Other   |            | 0.09548    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 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:      214738.0 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.684500
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 = 312.649387453788, Press = 1.34523540991638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13077.901   -13077.901   -13241.484   -13241.484    316.46187    316.46187    67471.526    67471.526    147.86135    147.86135 
   32000   -13084.839   -13084.839   -13244.969   -13244.969    309.78204    309.78204    67544.569    67544.569   -756.76618   -756.76618 
Loop time of 234.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.020 hours/ns, 4.272 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    | 233.16     | 233.16     | 233.16     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11092    | 0.11092    | 0.11092    |   0.0 |  0.05
Output  | 0.00017744 | 0.00017744 | 0.00017744 |   0.0 |  0.00
Modify  | 0.70903    | 0.70903    | 0.70903    |   0.0 |  0.30
Other   |            | 0.09499    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4061.00 ave        4061 max        4061 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:      214626.0 ave      214626 max      214626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214626
Ave neighs/atom = 53.656500
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 = 312.747618667025, Press = -1.30366903675686
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13084.839   -13084.839   -13244.969   -13244.969    309.78204    309.78204    67544.569    67544.569   -756.76618   -756.76618 
   33000   -13081.223   -13081.223   -13243.889   -13243.889    314.68816    314.68816    67439.827    67439.827    291.59954    291.59954 
Loop time of 231.317 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.255 hours/ns, 4.323 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    | 230.42     | 230.42     | 230.42     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10975    | 0.10975    | 0.10975    |   0.0 |  0.05
Output  | 0.00018005 | 0.00018005 | 0.00018005 |   0.0 |  0.00
Modify  | 0.69638    | 0.69638    | 0.69638    |   0.0 |  0.30
Other   |            | 0.09497    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4049.00 ave        4049 max        4049 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:      214644.0 ave      214644 max      214644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214644
Ave neighs/atom = 53.661000
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 = 312.759655135057, Press = -1.11281432422432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13081.223   -13081.223   -13243.889   -13243.889    314.68816    314.68816    67439.827    67439.827    291.59954    291.59954 
   34000   -13083.913   -13083.913    -13245.59    -13245.59    312.77501    312.77501     67451.49     67451.49    98.611477    98.611477 
Loop time of 232.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.372 ns/day, 64.547 hours/ns, 4.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    | 231.47     | 231.47     | 231.47     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11013    | 0.11013    | 0.11013    |   0.0 |  0.05
Output  | 0.00018215 | 0.00018215 | 0.00018215 |   0.0 |  0.00
Modify  | 0.69553    | 0.69553    | 0.69553    |   0.0 |  0.30
Other   |            | 0.09417    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4072.00 ave        4072 max        4072 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:      214738.0 ave      214738 max      214738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214738
Ave neighs/atom = 53.684500
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 = 312.746659293282, Press = -0.26828351532816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13083.913   -13083.913    -13245.59    -13245.59    312.77501    312.77501     67451.49     67451.49    98.611477    98.611477 
   35000   -13085.781   -13085.781   -13247.197   -13247.197    312.26999    312.26999    67504.612    67504.612   -465.77373   -465.77373 
Loop time of 231.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.172 hours/ns, 4.329 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    | 230.13     | 230.13     | 230.13     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10863    | 0.10863    | 0.10863    |   0.0 |  0.05
Output  | 0.00017797 | 0.00017797 | 0.00017797 |   0.0 |  0.00
Modify  | 0.68901    | 0.68901    | 0.68901    |   0.0 |  0.30
Other   |            | 0.09381    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4041.00 ave        4041 max        4041 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:      214770.0 ave      214770 max      214770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214770
Ave neighs/atom = 53.692500
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 = 312.68050741096, Press = -0.833134263935281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13085.781   -13085.781   -13247.197   -13247.197    312.26999    312.26999    67504.612    67504.612   -465.77373   -465.77373 
   36000   -13084.421   -13084.421   -13244.862   -13244.862    310.38409    310.38409    67407.897    67407.897    529.94663    529.94663 
Loop time of 231.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.386 hours/ns, 4.314 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    | 230.89     | 230.89     | 230.89     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10878    | 0.10878    | 0.10878    |   0.0 |  0.05
Output  | 0.00018674 | 0.00018674 | 0.00018674 |   0.0 |  0.00
Modify  | 0.69328    | 0.69328    | 0.69328    |   0.0 |  0.30
Other   |            | 0.09474    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4027.00 ave        4027 max        4027 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:      214664.0 ave      214664 max      214664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214664
Ave neighs/atom = 53.666000
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 = 312.694352702879, Press = -1.45101395058498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13084.421   -13084.421   -13244.862   -13244.862    310.38409    310.38409    67407.897    67407.897    529.94663    529.94663 
   37000   -13081.886   -13081.886   -13243.332   -13243.332     312.3279     312.3279    67412.323    67412.323    598.57402    598.57402 
Loop time of 230.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.375 ns/day, 63.939 hours/ns, 4.344 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    | 229.3      | 229.3      | 229.3      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10925    | 0.10925    | 0.10925    |   0.0 |  0.05
Output  | 0.00022959 | 0.00022959 | 0.00022959 |   0.0 |  0.00
Modify  | 0.68198    | 0.68198    | 0.68198    |   0.0 |  0.30
Other   |            | 0.09407    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 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:      214806.0 ave      214806 max      214806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214806
Ave neighs/atom = 53.701500
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 = 312.671259842189, Press = 0.399740238964448
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13081.886   -13081.886   -13243.332   -13243.332     312.3279     312.3279    67412.323    67412.323    598.57402    598.57402 
   38000   -13077.446   -13077.446   -13242.619   -13242.619    319.53931    319.53931    67600.698    67600.698   -1104.8793   -1104.8793 
Loop time of 229.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.376 ns/day, 63.758 hours/ns, 4.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.64     | 228.64     | 228.64     |   0.0 | 99.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10909    | 0.10909    | 0.10909    |   0.0 |  0.05
Output  | 0.00018054 | 0.00018054 | 0.00018054 |   0.0 |  0.00
Modify  | 0.68518    | 0.68518    | 0.68518    |   0.0 |  0.30
Other   |            | 0.09412    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4071.00 ave        4071 max        4071 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:      214790.0 ave      214790 max      214790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214790
Ave neighs/atom = 53.697500
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 = 312.712986672127, Press = -0.533277509907816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13077.446   -13077.446   -13242.619   -13242.619    319.53931    319.53931    67600.698    67600.698   -1104.8793   -1104.8793 
   39000   -13083.829   -13083.829   -13245.052   -13245.052    311.89686    311.89686     67443.93     67443.93    217.49839    217.49839 
Loop time of 227.683 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.245 hours/ns, 4.392 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    | 226.81     | 226.81     | 226.81     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10657    | 0.10657    | 0.10657    |   0.0 |  0.05
Output  | 0.00017842 | 0.00017842 | 0.00017842 |   0.0 |  0.00
Modify  | 0.67416    | 0.67416    | 0.67416    |   0.0 |  0.30
Other   |            | 0.09369    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4029.00 ave        4029 max        4029 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:      214624.0 ave      214624 max      214624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214624
Ave neighs/atom = 53.656000
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 = 312.770439079725, Press = -1.59255078047305
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13083.829   -13083.829   -13245.052   -13245.052    311.89686    311.89686     67443.93     67443.93    217.49839    217.49839 
   40000   -13082.385   -13082.385   -13245.436   -13245.436    315.43322    315.43322    67423.302    67423.302    425.67209    425.67209 
Loop time of 226.074 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.798 hours/ns, 4.423 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    | 225.21     | 225.21     | 225.21     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10596    | 0.10596    | 0.10596    |   0.0 |  0.05
Output  | 0.00017183 | 0.00017183 | 0.00017183 |   0.0 |  0.00
Modify  | 0.66472    | 0.66472    | 0.66472    |   0.0 |  0.29
Other   |            | 0.0939     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4079.00 ave        4079 max        4079 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:      214692.0 ave      214692 max      214692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214692
Ave neighs/atom = 53.673000
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 = 312.80547302098, Press = -0.305442022034206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13082.385   -13082.385   -13245.436   -13245.436    315.43322    315.43322    67423.302    67423.302    425.67209    425.67209 
   41000   -13076.493   -13076.493   -13242.102   -13242.102    320.38121    320.38121    67516.225    67516.225   -290.89985   -290.89985 
Loop time of 226.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 63.039 hours/ns, 4.406 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    | 226.07     | 226.07     | 226.07     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10615    | 0.10615    | 0.10615    |   0.0 |  0.05
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.66734    | 0.66734    | 0.66734    |   0.0 |  0.29
Other   |            | 0.09354    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4054.00 ave        4054 max        4054 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:      214780.0 ave      214780 max      214780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214780
Ave neighs/atom = 53.695000
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 = 312.838553873949, Press = -0.403535997794205
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13076.493   -13076.493   -13242.102   -13242.102    320.38121    320.38121    67516.225    67516.225   -290.89985   -290.89985 
   42000   -13083.228   -13083.228   -13244.578   -13244.578    312.14315    312.14315    67481.975    67481.975   -143.59427   -143.59427 
Loop time of 226.392 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.887 hours/ns, 4.417 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    | 225.52     | 225.52     | 225.52     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10706    | 0.10706    | 0.10706    |   0.0 |  0.05
Output  | 0.00023174 | 0.00023174 | 0.00023174 |   0.0 |  0.00
Modify  | 0.66959    | 0.66959    | 0.66959    |   0.0 |  0.30
Other   |            | 0.09257    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4059.00 ave        4059 max        4059 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:      214636.0 ave      214636 max      214636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214636
Ave neighs/atom = 53.659000
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 = 312.886261186101, Press = -0.839350777451528
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13083.228   -13083.228   -13244.578   -13244.578    312.14315    312.14315    67481.975    67481.975   -143.59427   -143.59427 
   43000   -13081.783   -13081.783   -13243.558   -13243.558    312.96605    312.96605    67422.742    67422.742    497.07829    497.07829 
Loop time of 226.743 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 62.984 hours/ns, 4.410 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    | 225.88     | 225.88     | 225.88     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10505    | 0.10505    | 0.10505    |   0.0 |  0.05
Output  | 0.00023227 | 0.00023227 | 0.00023227 |   0.0 |  0.00
Modify  | 0.66878    | 0.66878    | 0.66878    |   0.0 |  0.29
Other   |            | 0.09332    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4016.00 ave        4016 max        4016 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:      214618.0 ave      214618 max      214618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214618
Ave neighs/atom = 53.654500
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 = 312.919614605022, Press = -0.58214868611238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.145 | 4.145 | 4.145 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13081.783   -13081.783   -13243.558   -13243.558    312.96605    312.96605    67422.742    67422.742    497.07829    497.07829 
   44000    -13085.57    -13085.57    -13246.76    -13246.76    311.83304    311.83304    67480.251    67480.251   -193.44846   -193.44846 
Loop time of 226.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 62.953 hours/ns, 4.412 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    | 225.77     | 225.77     | 225.77     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1057     | 0.1057     | 0.1057     |   0.0 |  0.05
Output  | 0.00017754 | 0.00017754 | 0.00017754 |   0.0 |  0.00
Modify  | 0.66632    | 0.66632    | 0.66632    |   0.0 |  0.29
Other   |            | 0.09305    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4068.00 ave        4068 max        4068 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:      214804.0 ave      214804 max      214804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 214804
Ave neighs/atom = 53.701000
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67465.1855690017

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0