# 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.0469995588064185*${_u_distance}
variable latticeconst_converted equal 4.0469995588064185*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04699955880642
Lattice spacing in x,y,z = 4.0469996 4.0469996 4.0469996
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.469996 40.469996 40.469996)
  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.469996 40.469996 40.469996)
  create_atoms CPU = 0.005 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_AlmyrasSangiovanniSarakinos_2019_NAlTi__MO_958395190627_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 66282.5901451204    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66282.5901451204/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66282.5901451204/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66282.5901451204/(1*1*${_u_distance})
variable      V0_metal equal 66282.5901451204/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66282.5901451204*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66282.5901451204 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 253.15*${_u_temperature}
variable temp_converted equal 253.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_958395190627_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13297.144   -13297.144       -13428       -13428       253.15       253.15     66282.59     66282.59    2108.7003    2108.7003 
    1000   -13155.868   -13155.868   -13284.386   -13284.386    248.62644    248.62644     67380.13     67380.13    976.68505    976.68505 
Loop time of 307.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.281 ns/day, 85.517 hours/ns, 3.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    | 306.84     | 306.84     | 306.84     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16072    | 0.16072    | 0.16072    |   0.0 |  0.05
Output  | 0.00022536 | 0.00022536 | 0.00022536 |   0.0 |  0.00
Modify  | 0.7538     | 0.7538     | 0.7538     |   0.0 |  0.24
Other   |            | 0.1024     |            |       |  0.03

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

Total # of neighbors = 344000
Ave neighs/atom = 86.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 = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13155.868   -13155.868   -13284.386   -13284.386    248.62644    248.62644     67380.13     67380.13    976.68505    976.68505 
    2000   -13166.267   -13166.267   -13295.802   -13295.802    250.59461    250.59461    67412.877    67412.877   -298.93257   -298.93257 
Loop time of 263.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.196 hours/ns, 3.795 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    | 262.62     | 262.62     | 262.62     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14585    | 0.14585    | 0.14585    |   0.0 |  0.06
Output  | 0.00021326 | 0.00021326 | 0.00021326 |   0.0 |  0.00
Modify  | 0.64057    | 0.64057    | 0.64057    |   0.0 |  0.24
Other   |            | 0.09502    |            |       |  0.04

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

Total # of neighbors = 332392
Ave neighs/atom = 83.098000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13166.267   -13166.267   -13295.802   -13295.802    250.59461    250.59461    67412.877    67412.877   -298.93257   -298.93257 
    3000   -13163.668   -13163.668   -13292.796   -13292.796    249.80589    249.80589    67401.525    67401.525    77.172095    77.172095 
Loop time of 264.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.506 hours/ns, 3.779 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    | 263.74     | 263.74     | 263.74     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1475     | 0.1475     | 0.1475     |   0.0 |  0.06
Output  | 0.00021569 | 0.00021569 | 0.00021569 |   0.0 |  0.00
Modify  | 0.63836    | 0.63836    | 0.63836    |   0.0 |  0.24
Other   |            | 0.09502    |            |       |  0.04

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

Total # of neighbors = 332492
Ave neighs/atom = 83.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13163.668   -13163.668   -13292.796   -13292.796    249.80589    249.80589    67401.525    67401.525    77.172095    77.172095 
    4000   -13160.716   -13160.716   -13292.446   -13292.446    254.84029    254.84029    67406.396    67406.396    79.568718    79.568718 
Loop time of 264.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.566 hours/ns, 3.776 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    | 263.95     | 263.95     | 263.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14794    | 0.14794    | 0.14794    |   0.0 |  0.06
Output  | 0.00021578 | 0.00021578 | 0.00021578 |   0.0 |  0.00
Modify  | 0.6423     | 0.6423     | 0.6423     |   0.0 |  0.24
Other   |            | 0.0935     |            |       |  0.04

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

Total # of neighbors = 332434
Ave neighs/atom = 83.108500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13160.716   -13160.716   -13292.446   -13292.446    254.84029    254.84029    67406.396    67406.396    79.568718    79.568718 
    5000   -13167.588   -13167.588   -13296.787   -13296.787    249.94378    249.94378    67381.584    67381.584    -58.35694    -58.35694 
Loop time of 265.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.762 hours/ns, 3.766 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    | 264.65     | 264.65     | 264.65     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1465     | 0.1465     | 0.1465     |   0.0 |  0.06
Output  | 0.00017725 | 0.00017725 | 0.00017725 |   0.0 |  0.00
Modify  | 0.64888    | 0.64888    | 0.64888    |   0.0 |  0.24
Other   |            | 0.09532    |            |       |  0.04

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

Total # of neighbors = 332554
Ave neighs/atom = 83.138500
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 = 250.048110193228, Press = 230.907402151494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13167.588   -13167.588   -13296.787   -13296.787    249.94378    249.94378    67381.584    67381.584    -58.35694    -58.35694 
    6000   -13159.006   -13159.006   -13293.217   -13293.217    259.63981    259.63981    67420.716    67420.716   -123.98016   -123.98016 
Loop time of 288.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.300 ns/day, 80.128 hours/ns, 3.467 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 287.45     | 287.45     | 287.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15702    | 0.15702    | 0.15702    |   0.0 |  0.05
Output  | 0.0001757  | 0.0001757  | 0.0001757  |   0.0 |  0.00
Modify  | 0.75286    | 0.75286    | 0.75286    |   0.0 |  0.26
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 332714
Ave neighs/atom = 83.178500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.674643229494, Press = 17.7890226166373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13159.006   -13159.006   -13293.217   -13293.217    259.63981    259.63981    67420.716    67420.716   -123.98016   -123.98016 
    7000   -13167.049   -13167.049    -13294.87    -13294.87    247.27938    247.27938    67476.124    67476.124   -959.07033   -959.07033 
Loop time of 264.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.474 hours/ns, 3.781 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    | 263.6      | 263.6      | 263.6      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1458     | 0.1458     | 0.1458     |   0.0 |  0.06
Output  | 0.00017988 | 0.00017988 | 0.00017988 |   0.0 |  0.00
Modify  | 0.66374    | 0.66374    | 0.66374    |   0.0 |  0.25
Other   |            | 0.09471    |            |       |  0.04

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

Total # of neighbors = 332542
Ave neighs/atom = 83.135500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.971122954734, Press = 0.432603108106327
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13167.049   -13167.049    -13294.87    -13294.87    247.27938    247.27938    67476.124    67476.124   -959.07033   -959.07033 
    8000   -13162.613   -13162.613    -13291.71    -13291.71     249.7471     249.7471    67425.421    67425.421   -137.79208   -137.79208 
Loop time of 267.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.323 ns/day, 74.284 hours/ns, 3.739 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.51     | 266.51     | 266.51     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14905    | 0.14905    | 0.14905    |   0.0 |  0.06
Output  | 0.00017668 | 0.00017668 | 0.00017668 |   0.0 |  0.00
Modify  | 0.6704     | 0.6704     | 0.6704     |   0.0 |  0.25
Other   |            | 0.09495    |            |       |  0.04

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

Total # of neighbors = 332342
Ave neighs/atom = 83.085500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.778480096732, Press = -11.6339225603167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13162.613   -13162.613    -13291.71    -13291.71     249.7471     249.7471    67425.421    67425.421   -137.79208   -137.79208 
    9000   -13161.986   -13161.986   -13293.553   -13293.553    254.52569    254.52569    67330.398    67330.398    839.99977    839.99977 
Loop time of 264.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.354 hours/ns, 3.787 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    | 263.17     | 263.17     | 263.17     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14782    | 0.14782    | 0.14782    |   0.0 |  0.06
Output  | 0.00022366 | 0.00022366 | 0.00022366 |   0.0 |  0.00
Modify  | 0.6637     | 0.6637     | 0.6637     |   0.0 |  0.25
Other   |            | 0.09504    |            |       |  0.04

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

Total # of neighbors = 332482
Ave neighs/atom = 83.120500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.388983729138, Press = 0.159003776717414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13161.986   -13161.986   -13293.553   -13293.553    254.52569    254.52569    67330.398    67330.398    839.99977    839.99977 
   10000   -13166.035   -13166.035   -13295.792   -13295.792    251.02264    251.02264    67342.586    67342.586    471.26167    471.26167 
Loop time of 271.992 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.318 ns/day, 75.553 hours/ns, 3.677 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    | 271.05     | 271.05     | 271.05     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15083    | 0.15083    | 0.15083    |   0.0 |  0.06
Output  | 0.00023184 | 0.00023184 | 0.00023184 |   0.0 |  0.00
Modify  | 0.6918     | 0.6918     | 0.6918     |   0.0 |  0.25
Other   |            | 0.09578    |            |       |  0.04

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

Total # of neighbors = 332778
Ave neighs/atom = 83.194500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.420743365008, Press = 3.111455596955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13166.035   -13166.035   -13295.792   -13295.792    251.02264    251.02264    67342.586    67342.586    471.26167    471.26167 
   11000   -13161.688   -13161.688   -13295.199   -13295.199     258.2857     258.2857    67414.282    67414.282    -182.6698    -182.6698 
Loop time of 263.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.196 hours/ns, 3.795 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    | 262.6      | 262.6      | 262.6      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1464     | 0.1464     | 0.1464     |   0.0 |  0.06
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.66458    | 0.66458    | 0.66458    |   0.0 |  0.25
Other   |            | 0.09582    |            |       |  0.04

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

Total # of neighbors = 332738
Ave neighs/atom = 83.184500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.37239925087, Press = 4.15919006176801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13161.688   -13161.688   -13295.199   -13295.199     258.2857     258.2857    67414.282    67414.282    -182.6698    -182.6698 
   12000   -13164.937   -13164.937   -13295.895   -13295.895    253.34764    253.34764    67379.292    67379.292     109.8914     109.8914 
Loop time of 264.468 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.463 hours/ns, 3.781 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    | 263.56     | 263.56     | 263.56     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14699    | 0.14699    | 0.14699    |   0.0 |  0.06
Output  | 0.00022395 | 0.00022395 | 0.00022395 |   0.0 |  0.00
Modify  | 0.66675    | 0.66675    | 0.66675    |   0.0 |  0.25
Other   |            | 0.09566    |            |       |  0.04

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

Total # of neighbors = 332502
Ave neighs/atom = 83.125500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.272583783772, Press = 2.54395879640782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13164.937   -13164.937   -13295.895   -13295.895    253.34764    253.34764    67379.292    67379.292     109.8914     109.8914 
   13000   -13162.124   -13162.124   -13291.959   -13291.959    251.17327    251.17327    67421.786    67421.786   -68.871429   -68.871429 
Loop time of 263.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.237 hours/ns, 3.793 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    | 262.75     | 262.75     | 262.75     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14534    | 0.14534    | 0.14534    |   0.0 |  0.06
Output  | 0.00017646 | 0.00017646 | 0.00017646 |   0.0 |  0.00
Modify  | 0.66331    | 0.66331    | 0.66331    |   0.0 |  0.25
Other   |            | 0.09615    |            |       |  0.04

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

Total # of neighbors = 332776
Ave neighs/atom = 83.194000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.208938785221, Press = 1.92984345574349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13162.124   -13162.124   -13291.959   -13291.959    251.17327    251.17327    67421.786    67421.786   -68.871429   -68.871429 
   14000   -13166.536   -13166.536   -13295.195   -13295.195    248.89976    248.89976     67404.01     67404.01   -183.87374   -183.87374 
Loop time of 268.639 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.322 ns/day, 74.622 hours/ns, 3.722 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    | 267.73     | 267.73     | 267.73     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14757    | 0.14757    | 0.14757    |   0.0 |  0.05
Output  | 0.00017829 | 0.00017829 | 0.00017829 |   0.0 |  0.00
Modify  | 0.67056    | 0.67056    | 0.67056    |   0.0 |  0.25
Other   |            | 0.09375    |            |       |  0.03

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

Total # of neighbors = 332438
Ave neighs/atom = 83.109500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.963481070151, Press = 1.88314431504562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13166.536   -13166.536   -13295.195   -13295.195    248.89976    248.89976     67404.01     67404.01   -183.87374   -183.87374 
   15000   -13161.238   -13161.238   -13292.371   -13292.371    253.68548    253.68548    67466.222    67466.222   -585.72459   -585.72459 
Loop time of 263.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.189 hours/ns, 3.795 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    | 262.57     | 262.57     | 262.57     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14402    | 0.14402    | 0.14402    |   0.0 |  0.05
Output  | 0.00043233 | 0.00043233 | 0.00043233 |   0.0 |  0.00
Modify  | 0.66285    | 0.66285    | 0.66285    |   0.0 |  0.25
Other   |            | 0.09711    |            |       |  0.04

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

Total # of neighbors = 332614
Ave neighs/atom = 83.153500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.898097387028, Press = 0.214954205722605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13161.238   -13161.238   -13292.371   -13292.371    253.68548    253.68548    67466.222    67466.222   -585.72459   -585.72459 
   16000    -13162.71    -13162.71   -13293.439   -13293.439     252.9041     252.9041    67358.529    67358.529    538.19895    538.19895 
Loop time of 263.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.213 hours/ns, 3.794 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    | 262.66     | 262.66     | 262.66     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14588    | 0.14588    | 0.14588    |   0.0 |  0.06
Output  | 0.00017725 | 0.00017725 | 0.00017725 |   0.0 |  0.00
Modify  | 0.66472    | 0.66472    | 0.66472    |   0.0 |  0.25
Other   |            | 0.09384    |            |       |  0.04

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

Total # of neighbors = 332264
Ave neighs/atom = 83.066000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.065587053276, Press = 0.453858831534011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -13162.71    -13162.71   -13293.439   -13293.439     252.9041     252.9041    67358.529    67358.529    538.19895    538.19895 
   17000   -13161.889   -13161.889   -13293.054   -13293.054    253.74804    253.74804    67335.057    67335.057    835.55259    835.55259 
Loop time of 266.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.940 hours/ns, 3.757 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    | 265.27     | 265.27     | 265.27     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14814    | 0.14814    | 0.14814    |   0.0 |  0.06
Output  | 0.00017932 | 0.00017932 | 0.00017932 |   0.0 |  0.00
Modify  | 0.66712    | 0.66712    | 0.66712    |   0.0 |  0.25
Other   |            | 0.09424    |            |       |  0.04

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

Total # of neighbors = 332592
Ave neighs/atom = 83.148000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.120205682576, Press = 2.33399668373376
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13161.889   -13161.889   -13293.054   -13293.054    253.74804    253.74804    67335.057    67335.057    835.55259    835.55259 
   18000   -13163.475   -13163.475   -13294.073   -13294.073    252.65186    252.65186    67392.772    67392.772    103.56364    103.56364 
Loop time of 284.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.304 ns/day, 79.006 hours/ns, 3.516 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    | 283.42     | 283.42     | 283.42     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15773    | 0.15773    | 0.15773    |   0.0 |  0.06
Output  | 0.00017917 | 0.00017917 | 0.00017917 |   0.0 |  0.00
Modify  | 0.74249    | 0.74249    | 0.74249    |   0.0 |  0.26
Other   |            | 0.09915    |            |       |  0.03

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

Total # of neighbors = 332780
Ave neighs/atom = 83.195000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.145496861364, Press = 3.10624556212916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13163.475   -13163.475   -13294.073   -13294.073    252.65186    252.65186    67392.772    67392.772    103.56364    103.56364 
   19000   -13165.439   -13165.439   -13292.994   -13292.994    246.76421    246.76421    67461.626    67461.626   -665.29375   -665.29375 
Loop time of 263.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.315 hours/ns, 3.789 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    | 263.02     | 263.02     | 263.02     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14694    | 0.14694    | 0.14694    |   0.0 |  0.06
Output  | 0.00017967 | 0.00017967 | 0.00017967 |   0.0 |  0.00
Modify  | 0.66512    | 0.66512    | 0.66512    |   0.0 |  0.25
Other   |            | 0.09787    |            |       |  0.04

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

Total # of neighbors = 332674
Ave neighs/atom = 83.168500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.070201196214, Press = 2.298268135436
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13165.439   -13165.439   -13292.994   -13292.994    246.76421    246.76421    67461.626    67461.626   -665.29375   -665.29375 
   20000   -13162.719   -13162.719   -13293.552   -13293.552    253.10463    253.10463    67484.338    67484.338   -869.89919   -869.89919 
Loop time of 267.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.323 ns/day, 74.333 hours/ns, 3.737 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    | 266.67     | 266.67     | 266.67     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14728    | 0.14728    | 0.14728    |   0.0 |  0.06
Output  | 0.00017765 | 0.00017765 | 0.00017765 |   0.0 |  0.00
Modify  | 0.67915    | 0.67915    | 0.67915    |   0.0 |  0.25
Other   |            | 0.09863    |            |       |  0.04

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

Total # of neighbors = 332436
Ave neighs/atom = 83.109000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.030645912706, Press = 0.319441635919195
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13162.719   -13162.719   -13293.552   -13293.552    253.10463    253.10463    67484.338    67484.338   -869.89919   -869.89919 
   21000   -13164.706   -13164.706   -13296.891   -13296.891    255.72128    255.72128    67395.439    67395.439   -165.26308   -165.26308 
Loop time of 272.184 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.317 ns/day, 75.607 hours/ns, 3.674 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    | 271.24     | 271.24     | 271.24     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15275    | 0.15275    | 0.15275    |   0.0 |  0.06
Output  | 0.00017797 | 0.00017797 | 0.00017797 |   0.0 |  0.00
Modify  | 0.69047    | 0.69047    | 0.69047    |   0.0 |  0.25
Other   |            | 0.09587    |            |       |  0.04

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

Total # of neighbors = 332422
Ave neighs/atom = 83.105500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.967979775599, Press = -0.326031881433593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13164.706   -13164.706   -13296.891   -13296.891    255.72128    255.72128    67395.439    67395.439   -165.26308   -165.26308 
   22000   -13158.576   -13158.576   -13292.781   -13292.781    259.62896    259.62896    67365.068    67365.068     546.3245     546.3245 
Loop time of 271.795 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.318 ns/day, 75.499 hours/ns, 3.679 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    | 270.86     | 270.86     | 270.86     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15056    | 0.15056    | 0.15056    |   0.0 |  0.06
Output  | 0.00017953 | 0.00017953 | 0.00017953 |   0.0 |  0.00
Modify  | 0.68913    | 0.68913    | 0.68913    |   0.0 |  0.25
Other   |            | 0.09519    |            |       |  0.04

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

Total # of neighbors = 332620
Ave neighs/atom = 83.155000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.043424212957, Press = 0.623719524805061
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13158.576   -13158.576   -13292.781   -13292.781    259.62896    259.62896    67365.068    67365.068     546.3245     546.3245 
   23000   -13161.842   -13161.842   -13294.072   -13294.072    255.80879    255.80879    67412.076    67412.076   -113.54251   -113.54251 
Loop time of 264.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.338 hours/ns, 3.788 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    | 263.11     | 263.11     | 263.11     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14387    | 0.14387    | 0.14387    |   0.0 |  0.05
Output  | 0.00017872 | 0.00017872 | 0.00017872 |   0.0 |  0.00
Modify  | 0.66471    | 0.66471    | 0.66471    |   0.0 |  0.25
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:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332700.0 ave      332700 max      332700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332700
Ave neighs/atom = 83.175000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.062299521047, Press = 2.06349880696402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13161.842   -13161.842   -13294.072   -13294.072    255.80879    255.80879    67412.076    67412.076   -113.54251   -113.54251 
   24000   -13165.326   -13165.326   -13295.381   -13295.381    251.60084    251.60084     67433.09     67433.09   -484.60364   -484.60364 
Loop time of 264.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.493 hours/ns, 3.780 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    | 263.67     | 263.67     | 263.67     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14568    | 0.14568    | 0.14568    |   0.0 |  0.06
Output  | 0.00019122 | 0.00019122 | 0.00019122 |   0.0 |  0.00
Modify  | 0.66375    | 0.66375    | 0.66375    |   0.0 |  0.25
Other   |            | 0.09534    |            |       |  0.04

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

Total # of neighbors = 332490
Ave neighs/atom = 83.122500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.981444061196, Press = 0.832552791676866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13165.326   -13165.326   -13295.381   -13295.381    251.60084    251.60084     67433.09     67433.09   -484.60364   -484.60364 
   25000   -13162.058   -13162.058   -13292.749   -13292.749    252.82973    252.82973    67498.933    67498.933   -993.32577   -993.32577 
Loop time of 264.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.556 hours/ns, 3.776 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    | 263.9      | 263.9      | 263.9      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14533    | 0.14533    | 0.14533    |   0.0 |  0.05
Output  | 0.00017674 | 0.00017674 | 0.00017674 |   0.0 |  0.00
Modify  | 0.66461    | 0.66461    | 0.66461    |   0.0 |  0.25
Other   |            | 0.09403    |            |       |  0.04

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

Total # of neighbors = 332528
Ave neighs/atom = 83.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.946317146537, Press = -0.279525911842075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13162.058   -13162.058   -13292.749   -13292.749    252.82973    252.82973    67498.933    67498.933   -993.32577   -993.32577 
   26000   -13167.104   -13167.104   -13295.306   -13295.306    248.01595    248.01595    67399.008    67399.008   -112.95595   -112.95595 
Loop time of 263.245 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.124 hours/ns, 3.799 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    | 262.35     | 262.35     | 262.35     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14271    | 0.14271    | 0.14271    |   0.0 |  0.05
Output  | 0.00017753 | 0.00017753 | 0.00017753 |   0.0 |  0.00
Modify  | 0.65992    | 0.65992    | 0.65992    |   0.0 |  0.25
Other   |            | 0.09658    |            |       |  0.04

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

Total # of neighbors = 332238
Ave neighs/atom = 83.059500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.880633532097, Press = -1.2761927094936
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13167.104   -13167.104   -13295.306   -13295.306    248.01595    248.01595    67399.008    67399.008   -112.95595   -112.95595 
   27000     -13163.5     -13163.5   -13294.249   -13294.249     252.9444     252.9444    67347.212    67347.212    587.59748    587.59748 
Loop time of 263.235 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.121 hours/ns, 3.799 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    | 262.33     | 262.33     | 262.33     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14281    | 0.14281    | 0.14281    |   0.0 |  0.05
Output  | 0.00017765 | 0.00017765 | 0.00017765 |   0.0 |  0.00
Modify  | 0.66002    | 0.66002    | 0.66002    |   0.0 |  0.25
Other   |            | 0.09714    |            |       |  0.04

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

Total # of neighbors = 332550
Ave neighs/atom = 83.137500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.853735614347, Press = -0.200758188845258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000     -13163.5     -13163.5   -13294.249   -13294.249     252.9444     252.9444    67347.212    67347.212    587.59748    587.59748 
   28000    -13159.68    -13159.68   -13293.641   -13293.641    259.15576    259.15576     67392.69     67392.69    196.75608    196.75608 
Loop time of 262.812 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 73.003 hours/ns, 3.805 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    | 261.91     | 261.91     | 261.91     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1431     | 0.1431     | 0.1431     |   0.0 |  0.05
Output  | 0.00022214 | 0.00022214 | 0.00022214 |   0.0 |  0.00
Modify  | 0.66101    | 0.66101    | 0.66101    |   0.0 |  0.25
Other   |            | 0.09641    |            |       |  0.04

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

Total # of neighbors = 332824
Ave neighs/atom = 83.206000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.847924364449, Press = 0.953658735139406
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -13159.68    -13159.68   -13293.641   -13293.641    259.15576    259.15576     67392.69     67392.69    196.75608    196.75608 
   29000   -13164.134   -13164.134   -13296.152   -13296.152    255.39732    255.39732    67402.186    67402.186    -171.3923    -171.3923 
Loop time of 262.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.875 hours/ns, 3.812 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    | 261.45     | 261.45     | 261.45     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14245    | 0.14245    | 0.14245    |   0.0 |  0.05
Output  | 0.00017638 | 0.00017638 | 0.00017638 |   0.0 |  0.00
Modify  | 0.66083    | 0.66083    | 0.66083    |   0.0 |  0.25
Other   |            | 0.09628    |            |       |  0.04

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

Total # of neighbors = 332666
Ave neighs/atom = 83.166500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.924602407223, Press = 1.11293551712008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13164.134   -13164.134   -13296.152   -13296.152    255.39732    255.39732    67402.186    67402.186    -171.3923    -171.3923 
   30000   -13162.556   -13162.556   -13291.978   -13291.978    250.37562    250.37562     67446.39     67446.39   -367.17685   -367.17685 
Loop time of 263.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.068 hours/ns, 3.802 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    | 262.14     | 262.14     | 262.14     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14344    | 0.14344    | 0.14344    |   0.0 |  0.05
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.66008    | 0.66008    | 0.66008    |   0.0 |  0.25
Other   |            | 0.09741    |            |       |  0.04

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

Total # of neighbors = 332640
Ave neighs/atom = 83.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.921811447547, Press = 0.762945774503887
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13162.556   -13162.556   -13291.978   -13291.978    250.37562    250.37562     67446.39     67446.39   -367.17685   -367.17685 
   31000   -13161.151   -13161.151   -13294.773   -13294.773    258.50072    258.50072    67505.213    67505.213   -1143.8795   -1143.8795 
Loop time of 262.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.893 hours/ns, 3.811 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    | 261.51     | 261.51     | 261.51     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14382    | 0.14382    | 0.14382    |   0.0 |  0.05
Output  | 0.00017589 | 0.00017589 | 0.00017589 |   0.0 |  0.00
Modify  | 0.6596     | 0.6596     | 0.6596     |   0.0 |  0.25
Other   |            | 0.09788    |            |       |  0.04

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

Total # of neighbors = 332238
Ave neighs/atom = 83.059500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.931747002034, Press = -0.254875418585157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13161.151   -13161.151   -13294.773   -13294.773    258.50072    258.50072    67505.213    67505.213   -1143.8795   -1143.8795 
   32000   -13167.401   -13167.401   -13295.887   -13295.887    248.56575    248.56575    67359.615    67359.615    288.06455    288.06455 
Loop time of 263.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.260 hours/ns, 3.792 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    | 262.83     | 262.83     | 262.83     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14481    | 0.14481    | 0.14481    |   0.0 |  0.05
Output  | 0.00017684 | 0.00017684 | 0.00017684 |   0.0 |  0.00
Modify  | 0.6621     | 0.6621     | 0.6621     |   0.0 |  0.25
Other   |            | 0.09693    |            |       |  0.04

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

Total # of neighbors = 332350
Ave neighs/atom = 83.087500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.927180827319, Press = -1.21356751950536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13167.401   -13167.401   -13295.887   -13295.887    248.56575    248.56575    67359.615    67359.615    288.06455    288.06455 
   33000   -13160.983   -13160.983   -13294.939   -13294.939    259.14607    259.14607     67350.94     67350.94    528.87816    528.87816 
Loop time of 263.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.253 hours/ns, 3.792 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    | 262.81     | 262.81     | 262.81     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14356    | 0.14356    | 0.14356    |   0.0 |  0.05
Output  | 0.00017711 | 0.00017711 | 0.00017711 |   0.0 |  0.00
Modify  | 0.66227    | 0.66227    | 0.66227    |   0.0 |  0.25
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:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332640.0 ave      332640 max      332640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332640
Ave neighs/atom = 83.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.90505656089, Press = 0.0895924477232553
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13160.983   -13160.983   -13294.939   -13294.939    259.14607    259.14607     67350.94     67350.94    528.87816    528.87816 
   34000   -13163.001   -13163.001   -13295.022   -13295.022    255.40265    255.40265    67325.397    67325.397    763.83641    763.83641 
Loop time of 263.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.174 hours/ns, 3.796 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    | 262.52     | 262.52     | 262.52     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14368    | 0.14368    | 0.14368    |   0.0 |  0.05
Output  | 0.0001783  | 0.0001783  | 0.0001783  |   0.0 |  0.00
Modify  | 0.66493    | 0.66493    | 0.66493    |   0.0 |  0.25
Other   |            | 0.0966     |            |       |  0.04

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

Total # of neighbors = 332790
Ave neighs/atom = 83.197500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.926044553732, Press = 0.661230107727605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13163.001   -13163.001   -13295.022   -13295.022    255.40265    255.40265    67325.397    67325.397    763.83641    763.83641 
   35000   -13165.254   -13165.254   -13294.823   -13294.823    250.65971    250.65971    67378.683    67378.683    132.09145    132.09145 
Loop time of 263.381 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.161 hours/ns, 3.797 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    | 262.48     | 262.48     | 262.48     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14303    | 0.14303    | 0.14303    |   0.0 |  0.05
Output  | 0.00023198 | 0.00023198 | 0.00023198 |   0.0 |  0.00
Modify  | 0.66435    | 0.66435    | 0.66435    |   0.0 |  0.25
Other   |            | 0.09686    |            |       |  0.04

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

Total # of neighbors = 332864
Ave neighs/atom = 83.216000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.982790584339, Press = 1.68877161821781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13165.254   -13165.254   -13294.823   -13294.823    250.65971    250.65971    67378.683    67378.683    132.09145    132.09145 
   36000   -13162.604   -13162.604   -13293.215   -13293.215    252.67511    252.67511    67453.205    67453.205   -537.54719   -537.54719 
Loop time of 263.58 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.217 hours/ns, 3.794 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    | 262.67     | 262.67     | 262.67     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14413    | 0.14413    | 0.14413    |   0.0 |  0.05
Output  | 0.00017656 | 0.00017656 | 0.00017656 |   0.0 |  0.00
Modify  | 0.66405    | 0.66405    | 0.66405    |   0.0 |  0.25
Other   |            | 0.09728    |            |       |  0.04

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

Total # of neighbors = 332686
Ave neighs/atom = 83.171500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.015867147361, Press = 0.671102715096872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13162.604   -13162.604   -13293.215   -13293.215    252.67511    252.67511    67453.205    67453.205   -537.54719   -537.54719 
   37000   -13161.508   -13161.508   -13293.247   -13293.247    254.85713    254.85713    67456.649    67456.649   -514.98277   -514.98277 
Loop time of 263.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.095 hours/ns, 3.800 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    | 262.24     | 262.24     | 262.24     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1425     | 0.1425     | 0.1425     |   0.0 |  0.05
Output  | 0.00017658 | 0.00017658 | 0.00017658 |   0.0 |  0.00
Modify  | 0.66371    | 0.66371    | 0.66371    |   0.0 |  0.25
Other   |            | 0.09716    |            |       |  0.04

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0