# 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.045353233814239*${_u_distance}
variable latticeconst_converted equal 4.045353233814239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04535323381424
Lattice spacing in x,y,z = 4.0453532 4.0453532 4.0453532
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.453532 40.453532 40.453532)
  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.453532 40.453532 40.453532)
  create_atoms CPU = 0.002 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_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_000
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 66201.7315006764    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*1*${_u_distance})
variable      V0_metal equal 66201.7315006764/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66201.7315006764*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13278.286   -13278.286   -13440.157   -13440.157       313.15       313.15    66201.732    66201.732     2611.676     2611.676 
    1000   -13102.877   -13102.877   -13261.371   -13261.371    306.61863    306.61863    67564.546    67564.546   -959.51325   -959.51325 
Loop time of 225.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.703 hours/ns, 4.430 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.94     | 224.94     | 224.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099245   | 0.099245   | 0.099245   |   0.0 |  0.04
Output  | 0.00052177 | 0.00052177 | 0.00052177 |   0.0 |  0.00
Modify  | 0.6048     | 0.6048     | 0.6048     |   0.0 |  0.27
Other   |            | 0.08593    |            |       |  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:      216000.0 ave      216000 max      216000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.409 ns/day, 58.650 hours/ns, 4.736 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    | 210.43     | 210.43     | 210.43     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.086385   | 0.086385   | 0.086385   |   0.0 |  0.04
Output  | 0.00023831 | 0.00023831 | 0.00023831 |   0.0 |  0.00
Modify  | 0.54609    | 0.54609    | 0.54609    |   0.0 |  0.26
Other   |            | 0.07987    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5647.00 ave        5647 max        5647 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:      224122.0 ave      224122 max      224122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224122
Ave neighs/atom = 56.030500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13117.523   -13117.523   -13271.534   -13271.534    297.94551    297.94551    67358.369    67358.369     623.3427     623.3427 
    3000   -13107.202   -13107.202   -13271.948   -13271.948    318.71253    318.71253    67428.917    67428.917    25.562915    25.562915 
Loop time of 240.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.360 ns/day, 66.738 hours/ns, 4.162 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 239.45     | 239.45     | 239.45     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098191   | 0.098191   | 0.098191   |   0.0 |  0.04
Output  | 0.0002363  | 0.0002363  | 0.0002363  |   0.0 |  0.00
Modify  | 0.61908    | 0.61908    | 0.61908    |   0.0 |  0.26
Other   |            | 0.08688    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5656.00 ave        5656 max        5656 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:      224266.0 ave      224266 max      224266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224266
Ave neighs/atom = 56.066500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13107.202   -13107.202   -13271.948   -13271.948    318.71253    318.71253    67428.917    67428.917    25.562915    25.562915 
    4000   -13115.623   -13115.623   -13274.993   -13274.993    308.31216    308.31216    67423.772    67423.772   -178.68147   -178.68147 
Loop time of 240.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.359 ns/day, 66.939 hours/ns, 4.150 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 240.18     | 240.18     | 240.18     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096491   | 0.096491   | 0.096491   |   0.0 |  0.04
Output  | 0.00022696 | 0.00022696 | 0.00022696 |   0.0 |  0.00
Modify  | 0.61672    | 0.61672    | 0.61672    |   0.0 |  0.26
Other   |            | 0.08467    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5640.00 ave        5640 max        5640 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:      223642.0 ave      223642 max      223642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223642
Ave neighs/atom = 55.910500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13115.623   -13115.623   -13274.993   -13274.993    308.31216    308.31216    67423.772    67423.772   -178.68147   -178.68147 
    5000    -13108.28    -13108.28   -13270.547   -13270.547    313.91713    313.91713    67388.344    67388.344    422.19919    422.19919 
Loop time of 222.94 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.928 hours/ns, 4.486 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.2      | 222.2      | 222.2      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089583   | 0.089583   | 0.089583   |   0.0 |  0.04
Output  | 0.00017538 | 0.00017538 | 0.00017538 |   0.0 |  0.00
Modify  | 0.5732     | 0.5732     | 0.5732     |   0.0 |  0.26
Other   |            | 0.08088    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5686.00 ave        5686 max        5686 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:      223910.0 ave      223910 max      223910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223910
Ave neighs/atom = 55.977500
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 = 319.409515069043, Press = -111.338691975692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -13108.28    -13108.28   -13270.547   -13270.547    313.91713    313.91713    67388.344    67388.344    422.19919    422.19919 
    6000   -13114.569   -13114.569   -13271.654   -13271.654    303.89031    303.89031    67476.783    67476.783   -598.23848   -598.23848 
Loop time of 239.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.361 ns/day, 66.563 hours/ns, 4.173 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    | 238.82     | 238.82     | 238.82     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094916   | 0.094916   | 0.094916   |   0.0 |  0.04
Output  | 0.00036019 | 0.00036019 | 0.00036019 |   0.0 |  0.00
Modify  | 0.62914    | 0.62914    | 0.62914    |   0.0 |  0.26
Other   |            | 0.08424    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5638.00 ave        5638 max        5638 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:      224326.0 ave      224326 max      224326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224326
Ave neighs/atom = 56.081500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.842713247789, Press = -11.4541755705317
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13114.569   -13114.569   -13271.654   -13271.654    303.89031    303.89031    67476.783    67476.783   -598.23848   -598.23848 
    7000   -13109.923   -13109.923   -13271.977   -13271.977    313.50394    313.50394    67350.886    67350.886    836.69677    836.69677 
Loop time of 226.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.851 hours/ns, 4.420 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.49     | 225.49     | 225.49     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.090823   | 0.090823   | 0.090823   |   0.0 |  0.04
Output  | 0.00041118 | 0.00041118 | 0.00041118 |   0.0 |  0.00
Modify  | 0.59753    | 0.59753    | 0.59753    |   0.0 |  0.26
Other   |            | 0.08165    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5653.00 ave        5653 max        5653 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:      223876.0 ave      223876 max      223876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223876
Ave neighs/atom = 55.969000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.439651507531, Press = 19.8725001810168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13109.923   -13109.923   -13271.977   -13271.977    313.50394    313.50394    67350.886    67350.886    836.69677    836.69677 
    8000   -13110.037   -13110.037   -13271.801   -13271.801    312.94395    312.94395    67421.167    67421.167    38.786369    38.786369 
Loop time of 230.977 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.374 ns/day, 64.160 hours/ns, 4.329 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.19     | 230.19     | 230.19     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093452   | 0.093452   | 0.093452   |   0.0 |  0.04
Output  | 0.00034455 | 0.00034455 | 0.00034455 |   0.0 |  0.00
Modify  | 0.61022    | 0.61022    | 0.61022    |   0.0 |  0.26
Other   |            | 0.08333    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5689.00 ave        5689 max        5689 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:      224094.0 ave      224094 max      224094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224094
Ave neighs/atom = 56.023500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.174004505256, Press = -15.1125417501392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13110.037   -13110.037   -13271.801   -13271.801    312.94395    312.94395    67421.167    67421.167    38.786369    38.786369 
    9000   -13113.837   -13113.837   -13274.861   -13274.861    311.51216    311.51216     67453.02     67453.02   -489.30991   -489.30991 
Loop time of 225.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.670 hours/ns, 4.432 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.83     | 224.83     | 224.83     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091103   | 0.091103   | 0.091103   |   0.0 |  0.04
Output  | 0.0003504  | 0.0003504  | 0.0003504  |   0.0 |  0.00
Modify  | 0.60171    | 0.60171    | 0.60171    |   0.0 |  0.27
Other   |            | 0.08462    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      223884.0 ave      223884 max      223884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223884
Ave neighs/atom = 55.971000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.747238197407, Press = 2.31516113210519
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13113.837   -13113.837   -13274.861   -13274.861    311.51216    311.51216     67453.02     67453.02   -489.30991   -489.30991 
   10000   -13110.646   -13110.646   -13274.017   -13274.017    316.05271    316.05271    67367.577    67367.577    498.66718    498.66718 
Loop time of 227.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.379 ns/day, 63.302 hours/ns, 4.388 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    | 227.11     | 227.11     | 227.11     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09101    | 0.09101    | 0.09101    |   0.0 |  0.04
Output  | 0.0001634  | 0.0001634  | 0.0001634  |   0.0 |  0.00
Modify  | 0.60156    | 0.60156    | 0.60156    |   0.0 |  0.26
Other   |            | 0.08217    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5636.00 ave        5636 max        5636 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:      223486.0 ave      223486 max      223486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223486
Ave neighs/atom = 55.871500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.527499500272, Press = -0.540641169284547
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13110.646   -13110.646   -13274.017   -13274.017    316.05271    316.05271    67367.577    67367.577    498.66718    498.66718 
   11000     -13114.5     -13114.5   -13275.565   -13275.565    311.59205    311.59205    67458.976    67458.976   -500.78019   -500.78019 
Loop time of 206.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.257 hours/ns, 4.851 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    | 205.42     | 205.42     | 205.42     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083422   | 0.083422   | 0.083422   |   0.0 |  0.04
Output  | 0.00020451 | 0.00020451 | 0.00020451 |   0.0 |  0.00
Modify  | 0.54755    | 0.54755    | 0.54755    |   0.0 |  0.27
Other   |            | 0.07744    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5683.00 ave        5683 max        5683 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:      224216.0 ave      224216 max      224216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224216
Ave neighs/atom = 56.054000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.133995832764, Press = -1.07215173301054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000     -13114.5     -13114.5   -13275.565   -13275.565    311.59205    311.59205    67458.976    67458.976   -500.78019   -500.78019 
   12000   -13114.151   -13114.151   -13274.508   -13274.508    310.22095    310.22095    67386.079    67386.079    337.93228    337.93228 
Loop time of 225.633 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.676 hours/ns, 4.432 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.85     | 224.85     | 224.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091965   | 0.091965   | 0.091965   |   0.0 |  0.04
Output  | 0.00017542 | 0.00017542 | 0.00017542 |   0.0 |  0.00
Modify  | 0.60296    | 0.60296    | 0.60296    |   0.0 |  0.27
Other   |            | 0.08391    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5667.00 ave        5667 max        5667 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:      223544.0 ave      223544 max      223544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223544
Ave neighs/atom = 55.886000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.120746252019, Press = 1.61960473623317
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13114.151   -13114.151   -13274.508   -13274.508    310.22095    310.22095    67386.079    67386.079    337.93228    337.93228 
   13000   -13113.526   -13113.526   -13276.862   -13276.862    315.98379    315.98379    67397.542    67397.542    26.717355    26.717355 
Loop time of 240.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.359 ns/day, 66.852 hours/ns, 4.155 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 239.85     | 239.85     | 239.85     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09719    | 0.09719    | 0.09719    |   0.0 |  0.04
Output  | 0.00033047 | 0.00033047 | 0.00033047 |   0.0 |  0.00
Modify  | 0.63463    | 0.63463    | 0.63463    |   0.0 |  0.26
Other   |            | 0.08465    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5714.00 ave        5714 max        5714 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:      223686.0 ave      223686 max      223686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223686
Ave neighs/atom = 55.921500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.176236189413, Press = -5.19401875619169
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13113.526   -13113.526   -13276.862   -13276.862    315.98379    315.98379    67397.542    67397.542    26.717355    26.717355 
   14000   -13115.263   -13115.263   -13273.245   -13273.245    305.62795    305.62795    67485.603    67485.603   -872.16753   -872.16753 
Loop time of 201.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.882 hours/ns, 4.971 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.48     | 200.48     | 200.48     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081343   | 0.081343   | 0.081343   |   0.0 |  0.04
Output  | 0.00017559 | 0.00017559 | 0.00017559 |   0.0 |  0.00
Modify  | 0.53675    | 0.53675    | 0.53675    |   0.0 |  0.27
Other   |            | 0.07711    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5624.00 ave        5624 max        5624 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:      223900.0 ave      223900 max      223900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223900
Ave neighs/atom = 55.975000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.280293378606, Press = 3.54321988622799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13115.263   -13115.263   -13273.245   -13273.245    305.62795    305.62795    67485.603    67485.603   -872.16753   -872.16753 
   15000   -13110.666   -13110.666   -13272.699   -13272.699     313.4627     313.4627    67353.452    67353.452    760.06858    760.06858 
Loop time of 174.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.496 ns/day, 48.371 hours/ns, 5.743 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    | 173.53     | 173.53     | 173.53     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070474   | 0.070474   | 0.070474   |   0.0 |  0.04
Output  | 0.0003451  | 0.0003451  | 0.0003451  |   0.0 |  0.00
Modify  | 0.46565    | 0.46565    | 0.46565    |   0.0 |  0.27
Other   |            | 0.07041    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5642.00 ave        5642 max        5642 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:      223718.0 ave      223718 max      223718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223718
Ave neighs/atom = 55.929500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.169130792174, Press = -1.46432343685735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13110.666   -13110.666   -13272.699   -13272.699     313.4627     313.4627    67353.452    67353.452    760.06858    760.06858 
   16000   -13111.973   -13111.973   -13273.967   -13273.967    313.38783    313.38783    67448.281    67448.281   -370.34868   -370.34868 
Loop time of 207.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.417 ns/day, 57.594 hours/ns, 4.823 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    | 206.62     | 206.62     | 206.62     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083759   | 0.083759   | 0.083759   |   0.0 |  0.04
Output  | 0.00017654 | 0.00017654 | 0.00017654 |   0.0 |  0.00
Modify  | 0.55161    | 0.55161    | 0.55161    |   0.0 |  0.27
Other   |            | 0.07988    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5642.00 ave        5642 max        5642 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:      224258.0 ave      224258 max      224258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224258
Ave neighs/atom = 56.064500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.180933619035, Press = -0.322974968307461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13111.973   -13111.973   -13273.967   -13273.967    313.38783    313.38783    67448.281    67448.281   -370.34868   -370.34868 
   17000   -13114.476   -13114.476   -13273.767   -13273.767    308.15895    308.15895    67393.442    67393.442    182.98387    182.98387 
Loop time of 150.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.575 ns/day, 41.712 hours/ns, 6.659 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    | 149.64     | 149.64     | 149.64     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061915   | 0.061915   | 0.061915   |   0.0 |  0.04
Output  | 9.5433e-05 | 9.5433e-05 | 9.5433e-05 |   0.0 |  0.00
Modify  | 0.40097    | 0.40097    | 0.40097    |   0.0 |  0.27
Other   |            | 0.06417    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      223686.0 ave      223686 max      223686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223686
Ave neighs/atom = 55.921500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.016990521373, Press = 0.439901279615647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13114.476   -13114.476   -13273.767   -13273.767    308.15895    308.15895    67393.442    67393.442    182.98387    182.98387 
   18000   -13111.777   -13111.777    -13274.23    -13274.23    314.27643    314.27643    67413.923    67413.923    12.951027    12.951027 
Loop time of 123.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.701 ns/day, 34.234 hours/ns, 8.114 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    | 122.81     | 122.81     | 122.81     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05038    | 0.05038    | 0.05038    |   0.0 |  0.04
Output  | 0.00013755 | 0.00013755 | 0.00013755 |   0.0 |  0.00
Modify  | 0.32732    | 0.32732    | 0.32732    |   0.0 |  0.27
Other   |            | 0.05138    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5629.00 ave        5629 max        5629 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:      223860.0 ave      223860 max      223860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223860
Ave neighs/atom = 55.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.947286795439, Press = -0.601195843869634
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13111.777   -13111.777    -13274.23    -13274.23    314.27643    314.27643    67413.923    67413.923    12.951027    12.951027 
   19000   -13109.162   -13109.162   -13273.796   -13273.796    318.49612    318.49612    67443.068    67443.068   -256.11754   -256.11754 
Loop time of 116.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.739 ns/day, 32.467 hours/ns, 8.556 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    | 116.47     | 116.47     | 116.47     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048125   | 0.048125   | 0.048125   |   0.0 |  0.04
Output  | 9.5788e-05 | 9.5788e-05 | 9.5788e-05 |   0.0 |  0.00
Modify  | 0.31009    | 0.31009    | 0.31009    |   0.0 |  0.27
Other   |            | 0.04889    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5699.00 ave        5699 max        5699 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:      223800.0 ave      223800 max      223800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223800
Ave neighs/atom = 55.950000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840932945496, Press = 0.0269111463978976
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13109.162   -13109.162   -13273.796   -13273.796    318.49612    318.49612    67443.068    67443.068   -256.11754   -256.11754 
   20000   -13113.274   -13113.274   -13272.299   -13272.299    307.64505    307.64505     67375.14     67375.14     436.7963     436.7963 
Loop time of 113.536 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.538 hours/ns, 8.808 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    | 113.14     | 113.14     | 113.14     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046438   | 0.046438   | 0.046438   |   0.0 |  0.04
Output  | 9.5864e-05 | 9.5864e-05 | 9.5864e-05 |   0.0 |  0.00
Modify  | 0.2999     | 0.2999     | 0.2999     |   0.0 |  0.26
Other   |            | 0.04741    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5694.00 ave        5694 max        5694 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:      223942.0 ave      223942 max      223942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223942
Ave neighs/atom = 55.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.919063335706, Press = 0.0544140569791605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13113.274   -13113.274   -13272.299   -13272.299    307.64505    307.64505     67375.14     67375.14     436.7963     436.7963 
   21000   -13108.755   -13108.755   -13272.739   -13272.739    317.23749    317.23749    67511.292    67511.292   -854.30871   -854.30871 
Loop time of 115.907 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.745 ns/day, 32.196 hours/ns, 8.628 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.5      | 115.5      | 115.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047761   | 0.047761   | 0.047761   |   0.0 |  0.04
Output  | 9.2982e-05 | 9.2982e-05 | 9.2982e-05 |   0.0 |  0.00
Modify  | 0.30765    | 0.30765    | 0.30765    |   0.0 |  0.27
Other   |            | 0.04896    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5710.00 ave        5710 max        5710 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:      224068.0 ave      224068 max      224068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224068
Ave neighs/atom = 56.017000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.020408926316, Press = -1.01846727976794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13108.755   -13108.755   -13272.739   -13272.739    317.23749    317.23749    67511.292    67511.292   -854.30871   -854.30871 
   22000   -13119.334   -13119.334   -13275.923   -13275.923    302.93247    302.93247    67282.383    67282.383    1242.1001    1242.1001 
Loop time of 115.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.747 ns/day, 32.146 hours/ns, 8.641 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    | 115.33     | 115.33     | 115.33     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047362   | 0.047362   | 0.047362   |   0.0 |  0.04
Output  | 0.00022015 | 0.00022015 | 0.00022015 |   0.0 |  0.00
Modify  | 0.30635    | 0.30635    | 0.30635    |   0.0 |  0.26
Other   |            | 0.04799    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5650.00 ave        5650 max        5650 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:      223700.0 ave      223700 max      223700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223700
Ave neighs/atom = 55.925000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.929344838888, Press = 1.28117953172859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13119.334   -13119.334   -13275.923   -13275.923    302.93247    302.93247    67282.383    67282.383    1242.1001    1242.1001 
   23000   -13110.421   -13110.421   -13273.214   -13273.214    314.93494    314.93494     67477.08     67477.08   -664.18246   -664.18246 
Loop time of 115.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 32.020 hours/ns, 8.675 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    | 114.87     | 114.87     | 114.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047604   | 0.047604   | 0.047604   |   0.0 |  0.04
Output  | 9.4696e-05 | 9.4696e-05 | 9.4696e-05 |   0.0 |  0.00
Modify  | 0.30734    | 0.30734    | 0.30734    |   0.0 |  0.27
Other   |            | 0.0495     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5734.00 ave        5734 max        5734 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:      223978.0 ave      223978 max      223978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223978
Ave neighs/atom = 55.994500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.894650924523, Press = -2.11419828717624
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13110.421   -13110.421   -13273.214   -13273.214    314.93494    314.93494     67477.08     67477.08   -664.18246   -664.18246 
   24000   -13115.398   -13115.398   -13275.067   -13275.067     308.8895     308.8895    67390.851    67390.851    51.858926    51.858926 
Loop time of 135.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.636 ns/day, 37.758 hours/ns, 7.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.46     | 135.46     | 135.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05521    | 0.05521    | 0.05521    |   0.0 |  0.04
Output  | 9.6618e-05 | 9.6618e-05 | 9.6618e-05 |   0.0 |  0.00
Modify  | 0.35913    | 0.35913    | 0.35913    |   0.0 |  0.26
Other   |            | 0.05582    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5629.00 ave        5629 max        5629 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:      223698.0 ave      223698 max      223698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223698
Ave neighs/atom = 55.924500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.811741917381, Press = 1.03024937001654
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13115.398   -13115.398   -13275.067   -13275.067     308.8895     308.8895    67390.851    67390.851    51.858926    51.858926 
   25000   -13106.686   -13106.686   -13268.996   -13268.996    314.00048    314.00048    67408.852    67408.852    283.55887    283.55887 
Loop time of 123.159 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.702 ns/day, 34.211 hours/ns, 8.120 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    | 122.73     | 122.73     | 122.73     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050198   | 0.050198   | 0.050198   |   0.0 |  0.04
Output  | 9.591e-05  | 9.591e-05  | 9.591e-05  |   0.0 |  0.00
Modify  | 0.32445    | 0.32445    | 0.32445    |   0.0 |  0.26
Other   |            | 0.04988    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5684.00 ave        5684 max        5684 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:      223756.0 ave      223756 max      223756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223756
Ave neighs/atom = 55.939000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.821647906748, Press = -0.249946231943177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13106.686   -13106.686   -13268.996   -13268.996    314.00048    314.00048    67408.852    67408.852    283.55887    283.55887 
   26000   -13112.689   -13112.689   -13273.923   -13273.923    311.91835    311.91835    67417.169    67417.169   -92.933707   -92.933707 
Loop time of 127.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.384 hours/ns, 7.850 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    | 126.94     | 126.94     | 126.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051803   | 0.051803   | 0.051803   |   0.0 |  0.04
Output  | 9.3951e-05 | 9.3951e-05 | 9.3951e-05 |   0.0 |  0.00
Modify  | 0.33645    | 0.33645    | 0.33645    |   0.0 |  0.26
Other   |            | 0.05155    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5649.00 ave        5649 max        5649 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:      224298.0 ave      224298 max      224298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224298
Ave neighs/atom = 56.074500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.848541523945, Press = -0.132006489469818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13112.689   -13112.689   -13273.923   -13273.923    311.91835    311.91835    67417.169    67417.169   -92.933707   -92.933707 
   27000   -13110.605   -13110.605   -13276.015   -13276.015    319.99616    319.99616    67445.958    67445.958   -391.89677   -391.89677 
Loop time of 126.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.685 ns/day, 35.050 hours/ns, 7.925 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    | 125.74     | 125.74     | 125.74     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051628   | 0.051628   | 0.051628   |   0.0 |  0.04
Output  | 9.4503e-05 | 9.4503e-05 | 9.4503e-05 |   0.0 |  0.00
Modify  | 0.33203    | 0.33203    | 0.33203    |   0.0 |  0.26
Other   |            | 0.05161    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5670.00 ave        5670 max        5670 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:      224178.0 ave      224178 max      224178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224178
Ave neighs/atom = 56.044500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889433059101, Press = -0.512797105211266
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13110.605   -13110.605   -13276.015   -13276.015    319.99616    319.99616    67445.958    67445.958   -391.89677   -391.89677 
   28000   -13108.658   -13108.658   -13268.753   -13268.753    309.71635    309.71635     67414.24     67414.24    196.57467    196.57467 
Loop time of 202.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.184 hours/ns, 4.944 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    | 201.57     | 201.57     | 201.57     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081605   | 0.081605   | 0.081605   |   0.0 |  0.04
Output  | 0.00017844 | 0.00017844 | 0.00017844 |   0.0 |  0.00
Modify  | 0.53296    | 0.53296    | 0.53296    |   0.0 |  0.26
Other   |            | 0.07552    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5697.00 ave        5697 max        5697 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:      223638.0 ave      223638 max      223638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223638
Ave neighs/atom = 55.909500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.877450432785, Press = 0.244773764054674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13108.658   -13108.658   -13268.753   -13268.753    309.71635    309.71635     67414.24     67414.24    196.57467    196.57467 
   29000   -13111.459   -13111.459   -13273.851   -13273.851    314.15849    314.15849    67414.462    67414.462    5.4656405    5.4656405 
Loop time of 206.171 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.270 hours/ns, 4.850 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    | 205.47     | 205.47     | 205.47     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083263   | 0.083263   | 0.083263   |   0.0 |  0.04
Output  | 0.00010923 | 0.00010923 | 0.00010923 |   0.0 |  0.00
Modify  | 0.54315    | 0.54315    | 0.54315    |   0.0 |  0.26
Other   |            | 0.07758    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5669.00 ave        5669 max        5669 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:      224122.0 ave      224122 max      224122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224122
Ave neighs/atom = 56.030500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.910427221819, Press = -0.515832709237986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13111.459   -13111.459   -13273.851   -13273.851    314.15849    314.15849    67414.462    67414.462    5.4656405    5.4656405 
   30000   -13111.996   -13111.996   -13272.759   -13272.759    311.00809    311.00809    67418.861    67418.861     81.69043     81.69043 
Loop time of 182.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.473 ns/day, 50.706 hours/ns, 5.478 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    | 181.91     | 181.91     | 181.91     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075082   | 0.075082   | 0.075082   |   0.0 |  0.04
Output  | 0.0001777  | 0.0001777  | 0.0001777  |   0.0 |  0.00
Modify  | 0.48076    | 0.48076    | 0.48076    |   0.0 |  0.26
Other   |            | 0.07339    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5656.00 ave        5656 max        5656 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:      223762.0 ave      223762 max      223762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223762
Ave neighs/atom = 55.940500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.886067587475, Press = -0.198389625661794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13111.996   -13111.996   -13272.759   -13272.759    311.00809    311.00809    67418.861    67418.861     81.69043     81.69043 
   31000   -13112.693   -13112.693   -13273.237   -13273.237    310.58292    310.58292     67405.81     67405.81    179.92279    179.92279 
Loop time of 145.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.595 ns/day, 40.350 hours/ns, 6.884 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    | 144.75     | 144.75     | 144.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060158   | 0.060158   | 0.060158   |   0.0 |  0.04
Output  | 8.5568e-05 | 8.5568e-05 | 8.5568e-05 |   0.0 |  0.00
Modify  | 0.38994    | 0.38994    | 0.38994    |   0.0 |  0.27
Other   |            | 0.06533    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5681.00 ave        5681 max        5681 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:      223696.0 ave      223696 max      223696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223696
Ave neighs/atom = 55.924000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.910157926431, Press = -0.312922222804824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13112.693   -13112.693   -13273.237   -13273.237    310.58292    310.58292     67405.81     67405.81    179.92279    179.92279 
   32000   -13114.869   -13114.869   -13274.528   -13274.528    308.87262    308.87262    67404.533    67404.533    31.959561    31.959561 
Loop time of 124.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.578 hours/ns, 8.033 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    | 124.04     | 124.04     | 124.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051469   | 0.051469   | 0.051469   |   0.0 |  0.04
Output  | 0.00014099 | 0.00014099 | 0.00014099 |   0.0 |  0.00
Modify  | 0.33136    | 0.33136    | 0.33136    |   0.0 |  0.27
Other   |            | 0.05301    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5670.00 ave        5670 max        5670 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:      223860.0 ave      223860 max      223860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223860
Ave neighs/atom = 55.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.934915570941, Press = -0.593387953340453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13114.869   -13114.869   -13274.528   -13274.528    308.87262    308.87262    67404.533    67404.533    31.959561    31.959561 
   33000   -13109.895   -13109.895   -13273.634   -13273.634     316.7628     316.7628    67421.294    67421.294   -29.423204   -29.423204 
Loop time of 126.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.686 ns/day, 35.011 hours/ns, 7.934 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    | 125.6      | 125.6      | 125.6      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051976   | 0.051976   | 0.051976   |   0.0 |  0.04
Output  | 0.00012129 | 0.00012129 | 0.00012129 |   0.0 |  0.00
Modify  | 0.33372    | 0.33372    | 0.33372    |   0.0 |  0.26
Other   |            | 0.0512     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5647.00 ave        5647 max        5647 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:      223886.0 ave      223886 max      223886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223886
Ave neighs/atom = 55.971500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.956936307448, Press = 0.342332353437513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13109.895   -13109.895   -13273.634   -13273.634     316.7628     316.7628    67421.294    67421.294   -29.423204   -29.423204 
   34000   -13110.207   -13110.207   -13270.329   -13270.329    309.76622    309.76622    67380.384    67380.384    524.48526    524.48526 
Loop time of 121.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.711 ns/day, 33.773 hours/ns, 8.225 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.16     | 121.16     | 121.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050234   | 0.050234   | 0.050234   |   0.0 |  0.04
Output  | 9.6646e-05 | 9.6646e-05 | 9.6646e-05 |   0.0 |  0.00
Modify  | 0.32114    | 0.32114    | 0.32114    |   0.0 |  0.26
Other   |            | 0.04941    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5701.00 ave        5701 max        5701 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:      223878.0 ave      223878 max      223878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223878
Ave neighs/atom = 55.969500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.917956381084, Press = -1.38077443510509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13110.207   -13110.207   -13270.329   -13270.329    309.76622    309.76622    67380.384    67380.384    524.48526    524.48526 
   35000   -13108.195   -13108.195   -13269.904   -13269.904    312.83643    312.83643    67523.625    67523.625   -901.57132   -901.57132 
Loop time of 121.53 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.711 ns/day, 33.758 hours/ns, 8.228 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.1      | 121.1      | 121.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050481   | 0.050481   | 0.050481   |   0.0 |  0.04
Output  | 8.3836e-05 | 8.3836e-05 | 8.3836e-05 |   0.0 |  0.00
Modify  | 0.32321    | 0.32321    | 0.32321    |   0.0 |  0.27
Other   |            | 0.0519     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5659.00 ave        5659 max        5659 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:      224442.0 ave      224442 max      224442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224442
Ave neighs/atom = 56.110500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.898544408525, Press = 0.792859924462869
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13108.195   -13108.195   -13269.904   -13269.904    312.83643    312.83643    67523.625    67523.625   -901.57132   -901.57132 
   36000   -13111.493   -13111.493   -13272.842   -13272.842    312.14027    312.14027     67328.93     67328.93    941.19583    941.19583 
Loop time of 189.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.697 hours/ns, 5.271 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    | 189.05     | 189.05     | 189.05     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076767   | 0.076767   | 0.076767   |   0.0 |  0.04
Output  | 0.00033315 | 0.00033315 | 0.00033315 |   0.0 |  0.00
Modify  | 0.5036     | 0.5036     | 0.5036     |   0.0 |  0.27
Other   |            | 0.07373    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      223726.0 ave      223726 max      223726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223726
Ave neighs/atom = 55.931500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.892873313219, Press = -0.660691100504951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13111.493   -13111.493   -13272.842   -13272.842    312.14027    312.14027     67328.93     67328.93    941.19583    941.19583 
   37000   -13113.811   -13113.811   -13273.717   -13273.717    309.34974    309.34974    67445.981    67445.981   -344.22014   -344.22014 
Loop time of 225.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.383 ns/day, 62.588 hours/ns, 4.438 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    | 224.56     | 224.56     | 224.56     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092121   | 0.092121   | 0.092121   |   0.0 |  0.04
Output  | 0.0001619  | 0.0001619  | 0.0001619  |   0.0 |  0.00
Modify  | 0.58246    | 0.58246    | 0.58246    |   0.0 |  0.26
Other   |            | 0.08       |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5669.00 ave        5669 max        5669 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:      224234.0 ave      224234 max      224234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224234
Ave neighs/atom = 56.058500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.92993362816, Press = -0.401445518162159
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13113.811   -13113.811   -13273.717   -13273.717    309.34974    309.34974    67445.981    67445.981   -344.22014   -344.22014 
   38000   -13108.159   -13108.159   -13271.096   -13271.096    315.21429    315.21429    67391.441    67391.441    377.43845    377.43845 
Loop time of 218.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.813 hours/ns, 4.568 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    | 218.2      | 218.2      | 218.2      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08924    | 0.08924    | 0.08924    |   0.0 |  0.04
Output  | 0.00025779 | 0.00025779 | 0.00025779 |   0.0 |  0.00
Modify  | 0.56084    | 0.56084    | 0.56084    |   0.0 |  0.26
Other   |            | 0.07554    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5669.00 ave        5669 max        5669 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:      223616.0 ave      223616 max      223616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223616
Ave neighs/atom = 55.904000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.934163584433, Press = -0.118869567100583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13108.159   -13108.159   -13271.096   -13271.096    315.21429    315.21429    67391.441    67391.441    377.43845    377.43845 
   39000   -13117.096   -13117.096   -13276.229   -13276.229    307.85332    307.85332    67427.503    67427.503   -337.05702   -337.05702 
Loop time of 212.692 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.081 hours/ns, 4.702 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    | 211.98     | 211.98     | 211.98     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087154   | 0.087154   | 0.087154   |   0.0 |  0.04
Output  | 0.00029442 | 0.00029442 | 0.00029442 |   0.0 |  0.00
Modify  | 0.54644    | 0.54644    | 0.54644    |   0.0 |  0.26
Other   |            | 0.07521    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5688.00 ave        5688 max        5688 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:      224176.0 ave      224176 max      224176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224176
Ave neighs/atom = 56.044000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.920933577197, Press = -0.742936930666117
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13117.096   -13117.096   -13276.229   -13276.229    307.85332    307.85332    67427.503    67427.503   -337.05702   -337.05702 
   40000   -13111.166   -13111.166   -13275.164   -13275.164    317.26558    317.26558    67388.392    67388.392    203.22954    203.22954 
Loop time of 204.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 56.944 hours/ns, 4.878 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    | 204.31     | 204.31     | 204.31     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083315   | 0.083315   | 0.083315   |   0.0 |  0.04
Output  | 0.00019154 | 0.00019154 | 0.00019154 |   0.0 |  0.00
Modify  | 0.52986    | 0.52986    | 0.52986    |   0.0 |  0.26
Other   |            | 0.07455    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5693.00 ave        5693 max        5693 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:      223880.0 ave      223880 max      223880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223880
Ave neighs/atom = 55.970000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864666697135, Press = 0.370902469792812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13111.166   -13111.166   -13275.164   -13275.164    317.26558    317.26558    67388.392    67388.392    203.22954    203.22954 
   41000   -13114.243   -13114.243   -13275.425   -13275.425    311.81845    311.81845    67382.674    67382.674    86.871521    86.871521 
Loop time of 189.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.513 hours/ns, 5.290 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    | 188.41     | 188.41     | 188.41     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077562   | 0.077562   | 0.077562   |   0.0 |  0.04
Output  | 0.00016486 | 0.00016486 | 0.00016486 |   0.0 |  0.00
Modify  | 0.49198    | 0.49198    | 0.49198    |   0.0 |  0.26
Other   |            | 0.07124    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5637.00 ave        5637 max        5637 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:      224076.0 ave      224076 max      224076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224076
Ave neighs/atom = 56.019000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.868784143303, Press = -1.29358546487557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13114.243   -13114.243   -13275.425   -13275.425    311.81845    311.81845    67382.674    67382.674    86.871521    86.871521 
   42000   -13104.387   -13104.387   -13269.499   -13269.499    319.41942    319.41942    67501.023    67501.023    -675.3762    -675.3762 
Loop time of 193.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.777 hours/ns, 5.165 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    | 192.94     | 192.94     | 192.94     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079107   | 0.079107   | 0.079107   |   0.0 |  0.04
Output  | 0.00017784 | 0.00017784 | 0.00017784 |   0.0 |  0.00
Modify  | 0.50103    | 0.50103    | 0.50103    |   0.0 |  0.26
Other   |            | 0.07211    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      224092.0 ave      224092 max      224092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224092
Ave neighs/atom = 56.023000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.909742056669, Press = 0.437219532076211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13104.387   -13104.387   -13269.499   -13269.499    319.41942    319.41942    67501.023    67501.023    -675.3762    -675.3762 
   43000   -13110.997   -13110.997   -13273.591   -13273.591    314.54936    314.54936     67344.69     67344.69    704.59065    704.59065 
Loop time of 205.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.092 hours/ns, 4.865 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    | 204.84     | 204.84     | 204.84     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083406   | 0.083406   | 0.083406   |   0.0 |  0.04
Output  | 0.00016582 | 0.00016582 | 0.00016582 |   0.0 |  0.00
Modify  | 0.52915    | 0.52915    | 0.52915    |   0.0 |  0.26
Other   |            | 0.07352    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5647.00 ave        5647 max        5647 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:      223960.0 ave      223960 max      223960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223960
Ave neighs/atom = 55.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.96086010887, Press = -0.834116343677827
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13110.997   -13110.997   -13273.591   -13273.591    314.54936    314.54936     67344.69     67344.69    704.59065    704.59065 
   44000   -13117.807   -13117.807   -13277.125   -13277.125    308.21233    308.21233    67480.348    67480.348   -967.23207   -967.23207 
Loop time of 234.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.095 hours/ns, 4.267 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.57     | 233.57     | 233.57     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095322   | 0.095322   | 0.095322   |   0.0 |  0.04
Output  | 0.00016597 | 0.00016597 | 0.00016597 |   0.0 |  0.00
Modify  | 0.59922    | 0.59922    | 0.59922    |   0.0 |  0.26
Other   |            | 0.07909    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      224032.0 ave      224032 max      224032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224032
Ave neighs/atom = 56.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918608640354, Press = -0.0112787819120425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13117.807   -13117.807   -13277.125   -13277.125    308.21233    308.21233    67480.348    67480.348   -967.23207   -967.23207 
   45000   -13110.791   -13110.791   -13273.893   -13273.893    315.53172    315.53172    67317.609    67317.609    1054.7123    1054.7123 
Loop time of 158.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.546 ns/day, 43.978 hours/ns, 6.316 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.78     | 157.78     | 157.78     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064923   | 0.064923   | 0.064923   |   0.0 |  0.04
Output  | 0.0002849  | 0.0002849  | 0.0002849  |   0.0 |  0.00
Modify  | 0.41492    | 0.41492    | 0.41492    |   0.0 |  0.26
Other   |            | 0.06406    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      223498.0 ave      223498 max      223498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223498
Ave neighs/atom = 55.874500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.901377282065, Press = -0.319539946767841
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13110.791   -13110.791   -13273.893   -13273.893    315.53172    315.53172    67317.609    67317.609    1054.7123    1054.7123 
   46000    -13115.93    -13115.93   -13274.322   -13274.322    306.42001    306.42001    67527.371    67527.371    -1264.852    -1264.852 
Loop time of 159.678 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.541 ns/day, 44.355 hours/ns, 6.263 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 159.13     | 159.13     | 159.13     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065519   | 0.065519   | 0.065519   |   0.0 |  0.04
Output  | 0.00035008 | 0.00035008 | 0.00035008 |   0.0 |  0.00
Modify  | 0.41842    | 0.41842    | 0.41842    |   0.0 |  0.26
Other   |            | 0.06516    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5675.00 ave        5675 max        5675 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:      224312.0 ave      224312 max      224312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224312
Ave neighs/atom = 56.078000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864238398728, Press = -0.708672189472232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -13115.93    -13115.93   -13274.322   -13274.322    306.42001    306.42001    67527.371    67527.371    -1264.852    -1264.852 
   47000   -13110.367   -13110.367   -13269.915   -13269.915     308.6552     308.6552    67293.817    67293.817    1447.6292    1447.6292 
Loop time of 133.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.075 hours/ns, 7.492 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    | 133.01     | 133.01     | 133.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054247   | 0.054247   | 0.054247   |   0.0 |  0.04
Output  | 9.7546e-05 | 9.7546e-05 | 9.7546e-05 |   0.0 |  0.00
Modify  | 0.35339    | 0.35339    | 0.35339    |   0.0 |  0.26
Other   |            | 0.05566    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5618.00 ave        5618 max        5618 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:      223528.0 ave      223528 max      223528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223528
Ave neighs/atom = 55.882000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.879229499804, Press = 0.527125065888075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13110.367   -13110.367   -13269.915   -13269.915     308.6552     308.6552    67293.817    67293.817    1447.6292    1447.6292 
   48000   -13109.127   -13109.127   -13272.554   -13272.554    316.16076    316.16076    67456.051    67456.051    -395.6131    -395.6131 
Loop time of 114.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.780 hours/ns, 8.741 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    | 114.01     | 114.01     | 114.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047151   | 0.047151   | 0.047151   |   0.0 |  0.04
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.30497    | 0.30497    | 0.30497    |   0.0 |  0.27
Other   |            | 0.04888    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5682.00 ave        5682 max        5682 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:      224764.0 ave      224764 max      224764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224764
Ave neighs/atom = 56.191000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866111973625, Press = -0.641996261399029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13109.127   -13109.127   -13272.554   -13272.554    316.16076    316.16076    67456.051    67456.051    -395.6131    -395.6131 
   49000   -13116.462   -13116.462   -13274.466   -13274.466    305.66936    305.66936    67385.254    67385.254    178.53436    178.53436 
Loop time of 113.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.509 hours/ns, 8.816 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    | 113.04     | 113.04     | 113.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046532   | 0.046532   | 0.046532   |   0.0 |  0.04
Output  | 9.5525e-05 | 9.5525e-05 | 9.5525e-05 |   0.0 |  0.00
Modify  | 0.29997    | 0.29997    | 0.29997    |   0.0 |  0.26
Other   |            | 0.04722    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5680.00 ave        5680 max        5680 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:      224074.0 ave      224074 max      224074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224074
Ave neighs/atom = 56.018500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.83978939826, Press = 0.228371679084615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13116.462   -13116.462   -13274.466   -13274.466    305.66936    305.66936    67385.254    67385.254    178.53436    178.53436 
   50000   -13110.633   -13110.633   -13275.431   -13275.431    318.81307    318.81307    67418.456    67418.456   -115.22096   -115.22096 
Loop time of 113.55 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.761 ns/day, 31.542 hours/ns, 8.807 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    | 113.16     | 113.16     | 113.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046168   | 0.046168   | 0.046168   |   0.0 |  0.04
Output  | 0.00010432 | 0.00010432 | 0.00010432 |   0.0 |  0.00
Modify  | 0.29866    | 0.29866    | 0.29866    |   0.0 |  0.26
Other   |            | 0.04703    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5672.00 ave        5672 max        5672 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:      224026.0 ave      224026 max      224026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224026
Ave neighs/atom = 56.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.821091370449, Press = -0.625749266666905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13110.633   -13110.633   -13275.431   -13275.431    318.81307    318.81307    67418.456    67418.456   -115.22096   -115.22096 
   51000   -13108.341   -13108.341   -13271.448   -13271.448     315.5412     315.5412    67461.557    67461.557   -289.89724   -289.89724 
Loop time of 113.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.508 hours/ns, 8.816 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    | 113.04     | 113.04     | 113.04     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046131   | 0.046131   | 0.046131   |   0.0 |  0.04
Output  | 9.5485e-05 | 9.5485e-05 | 9.5485e-05 |   0.0 |  0.00
Modify  | 0.29849    | 0.29849    | 0.29849    |   0.0 |  0.26
Other   |            | 0.04666    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5667.00 ave        5667 max        5667 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:      223922.0 ave      223922 max      223922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223922
Ave neighs/atom = 55.980500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.79493839203, Press = 0.396649627989794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13108.341   -13108.341   -13271.448   -13271.448     315.5412     315.5412    67461.557    67461.557   -289.89724   -289.89724 
   52000   -13113.732   -13113.732   -13276.387   -13276.387    314.66693    314.66693    67305.617    67305.617    1028.1603    1028.1603 
Loop time of 123.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.701 ns/day, 34.238 hours/ns, 8.113 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    | 122.83     | 122.83     | 122.83     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050692   | 0.050692   | 0.050692   |   0.0 |  0.04
Output  | 0.00023585 | 0.00023585 | 0.00023585 |   0.0 |  0.00
Modify  | 0.32594    | 0.32594    | 0.32594    |   0.0 |  0.26
Other   |            | 0.05126    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5684.00 ave        5684 max        5684 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:      223686.0 ave      223686 max      223686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223686
Ave neighs/atom = 55.921500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.837276396476, Press = -0.876081327982985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13113.732   -13113.732   -13276.387   -13276.387    314.66693    314.66693    67305.617    67305.617    1028.1603    1028.1603 
   53000   -13106.089   -13106.089   -13268.096   -13268.096    313.41434    313.41434    67534.016    67534.016   -961.20441   -961.20441 
Loop time of 116.959 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.739 ns/day, 32.489 hours/ns, 8.550 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    | 116.55     | 116.55     | 116.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048157   | 0.048157   | 0.048157   |   0.0 |  0.04
Output  | 8.7699e-05 | 8.7699e-05 | 8.7699e-05 |   0.0 |  0.00
Modify  | 0.31065    | 0.31065    | 0.31065    |   0.0 |  0.27
Other   |            | 0.04914    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5691.00 ave        5691 max        5691 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:      224320.0 ave      224320 max      224320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224320
Ave neighs/atom = 56.080000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864453174104, Press = -0.00821119129715873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13106.089   -13106.089   -13268.096   -13268.096    313.41434    313.41434    67534.016    67534.016   -961.20441   -961.20441 
   54000   -13112.286   -13112.286   -13272.582   -13272.582     310.1046     310.1046    67375.753    67375.753    457.42442    457.42442 
Loop time of 113.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.484 hours/ns, 8.823 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    | 112.95     | 112.95     | 112.95     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047123   | 0.047123   | 0.047123   |   0.0 |  0.04
Output  | 8.8762e-05 | 8.8762e-05 | 8.8762e-05 |   0.0 |  0.00
Modify  | 0.2981     | 0.2981     | 0.2981     |   0.0 |  0.26
Other   |            | 0.04631    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5653.00 ave        5653 max        5653 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:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 56.001000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.901098040455, Press = -0.181530849393855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13112.286   -13112.286   -13272.582   -13272.582     310.1046     310.1046    67375.753    67375.753    457.42442    457.42442 
   55000   -13110.651   -13110.651   -13270.878   -13270.878    309.96965    309.96965    67421.298    67421.298   -18.021279   -18.021279 
Loop time of 113.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.477 hours/ns, 8.825 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    | 112.92     | 112.92     | 112.92     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046456   | 0.046456   | 0.046456   |   0.0 |  0.04
Output  | 9.3172e-05 | 9.3172e-05 | 9.3172e-05 |   0.0 |  0.00
Modify  | 0.29947    | 0.29947    | 0.29947    |   0.0 |  0.26
Other   |            | 0.04711    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5678.00 ave        5678 max        5678 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:      224238.0 ave      224238 max      224238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224238
Ave neighs/atom = 56.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 = 312.891275190738, Press = -0.274329858623058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13110.651   -13110.651   -13270.878   -13270.878    309.96965    309.96965    67421.298    67421.298   -18.021279   -18.021279 
   56000   -13108.714   -13108.714    -13271.17    -13271.17    314.28244    314.28244    67406.289    67406.289    230.23975    230.23975 
Loop time of 129.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.666 ns/day, 36.018 hours/ns, 7.712 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    | 129.22     | 129.22     | 129.22     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05282    | 0.05282    | 0.05282    |   0.0 |  0.04
Output  | 9.9068e-05 | 9.9068e-05 | 9.9068e-05 |   0.0 |  0.00
Modify  | 0.34071    | 0.34071    | 0.34071    |   0.0 |  0.26
Other   |            | 0.05209    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5685.00 ave        5685 max        5685 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:      224322.0 ave      224322 max      224322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224322
Ave neighs/atom = 56.080500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.868862725579, Press = -0.013787930007704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13108.714   -13108.714    -13271.17    -13271.17    314.28244    314.28244    67406.289    67406.289    230.23975    230.23975 
   57000   -13110.343   -13110.343   -13271.323   -13271.323    311.42648    311.42648    67432.237    67432.237   -108.74541   -108.74541 
Loop time of 114.487 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.802 hours/ns, 8.735 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    | 114.1      | 114.1      | 114.1      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047031   | 0.047031   | 0.047031   |   0.0 |  0.04
Output  | 9.5024e-05 | 9.5024e-05 | 9.5024e-05 |   0.0 |  0.00
Modify  | 0.29969    | 0.29969    | 0.29969    |   0.0 |  0.26
Other   |            | 0.04459    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5680.00 ave        5680 max        5680 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:      224132.0 ave      224132 max      224132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224132
Ave neighs/atom = 56.033000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866676923051, Press = -0.750955424518378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13110.343   -13110.343   -13271.323   -13271.323    311.42648    311.42648    67432.237    67432.237   -108.74541   -108.74541 
   58000   -13113.059   -13113.059   -13273.477   -13273.477    310.34056    310.34056    67452.905    67452.905   -502.73579   -502.73579 
Loop time of 113.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.494 hours/ns, 8.820 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    | 112.98     | 112.98     | 112.98     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046871   | 0.046871   | 0.046871   |   0.0 |  0.04
Output  | 0.00021019 | 0.00021019 | 0.00021019 |   0.0 |  0.00
Modify  | 0.30003    | 0.30003    | 0.30003    |   0.0 |  0.26
Other   |            | 0.04688    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5671.00 ave        5671 max        5671 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:      224038.0 ave      224038 max      224038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224038
Ave neighs/atom = 56.009500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.905451993179, Press = 0.501641680420337
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.234 | 4.234 | 4.234 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13113.059   -13113.059   -13273.477   -13273.477    310.34056    310.34056    67452.905    67452.905   -502.73579   -502.73579 
   59000    -13111.75    -13111.75   -13274.366   -13274.366    314.59295    314.59295    67344.569    67344.569    749.90143    749.90143 
Loop time of 113.401 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.500 hours/ns, 8.818 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    | 113.01     | 113.01     | 113.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046748   | 0.046748   | 0.046748   |   0.0 |  0.04
Output  | 9.9133e-05 | 9.9133e-05 | 9.9133e-05 |   0.0 |  0.00
Modify  | 0.29946    | 0.29946    | 0.29946    |   0.0 |  0.26
Other   |            | 0.0468     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5656.00 ave        5656 max        5656 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:      224062.0 ave      224062 max      224062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224062
Ave neighs/atom = 56.015500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918922258884, Press = -0.815512707404299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000    -13111.75    -13111.75   -13274.366   -13274.366    314.59295    314.59295    67344.569    67344.569    749.90143    749.90143 
   60000   -13107.082   -13107.082   -13269.953   -13269.953    315.08506    315.08506    67504.186    67504.186   -682.04214   -682.04214 
Loop time of 113.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.510 hours/ns, 8.816 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    | 113.04     | 113.04     | 113.04     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046412   | 0.046412   | 0.046412   |   0.0 |  0.04
Output  | 9.7043e-05 | 9.7043e-05 | 9.7043e-05 |   0.0 |  0.00
Modify  | 0.29807    | 0.29807    | 0.29807    |   0.0 |  0.26
Other   |            | 0.04627    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5681.00 ave        5681 max        5681 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:      223934.0 ave      223934 max      223934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223934
Ave neighs/atom = 55.983500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.93620091586, Press = -0.0152306209284396
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13107.082   -13107.082   -13269.953   -13269.953    315.08506    315.08506    67504.186    67504.186   -682.04214   -682.04214 
   61000   -13112.805   -13112.805   -13273.054   -13273.054    310.01268    310.01268      67370.6      67370.6    428.80615    428.80615 
Loop time of 113.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.582 hours/ns, 8.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    | 113.3      | 113.3      | 113.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047185   | 0.047185   | 0.047185   |   0.0 |  0.04
Output  | 9.5487e-05 | 9.5487e-05 | 9.5487e-05 |   0.0 |  0.00
Modify  | 0.30077    | 0.30077    | 0.30077    |   0.0 |  0.26
Other   |            | 0.04843    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5668.00 ave        5668 max        5668 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:      223734.0 ave      223734 max      223734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223734
Ave neighs/atom = 55.933500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.960493178109, Press = -0.236921702646379
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -13112.805   -13112.805   -13273.054   -13273.054    310.01268    310.01268      67370.6      67370.6    428.80615    428.80615 
   62000   -13107.954   -13107.954   -13274.342   -13274.342      321.888      321.888    67468.413    67468.413   -556.56264   -556.56264 
Loop time of 114.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.898 hours/ns, 8.708 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    | 114.43     | 114.43     | 114.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047194   | 0.047194   | 0.047194   |   0.0 |  0.04
Output  | 9.4628e-05 | 9.4628e-05 | 9.4628e-05 |   0.0 |  0.00
Modify  | 0.30485    | 0.30485    | 0.30485    |   0.0 |  0.27
Other   |            | 0.04916    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5671.00 ave        5671 max        5671 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:      224074.0 ave      224074 max      224074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224074
Ave neighs/atom = 56.018500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.989479084919, Press = -0.343634446216844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.235 | 4.235 | 4.235 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13107.954   -13107.954   -13274.342   -13274.342      321.888      321.888    67468.413    67468.413   -556.56264   -556.56264 
   63000   -13118.943   -13118.943   -13277.472   -13277.472    306.68627    306.68627    67328.166    67328.166    550.17382    550.17382 
Loop time of 119.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.726 ns/day, 33.063 hours/ns, 8.401 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    | 118.62     | 118.62     | 118.62     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049028   | 0.049028   | 0.049028   |   0.0 |  0.04
Output  | 9.7036e-05 | 9.7036e-05 | 9.7036e-05 |   0.0 |  0.00
Modify  | 0.31304    | 0.31304    | 0.31304    |   0.0 |  0.26
Other   |            | 0.04726    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5721.00 ave        5721 max        5721 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:      223544.0 ave      223544 max      223544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0