# 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.001 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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   -13267.948   -13267.948   -13440.157   -13440.157       333.15       333.15    66201.732    66201.732    2778.4759    2778.4759 
    1000   -13080.424   -13080.424   -13248.345   -13248.345      324.855      324.855    67631.561    67631.561   -827.21279   -827.21279 
Loop time of 222.457 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.794 hours/ns, 4.495 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    | 221.69     | 221.69     | 221.69     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098894   | 0.098894   | 0.098894   |   0.0 |  0.04
Output  | 0.00049571 | 0.00049571 | 0.00049571 |   0.0 |  0.00
Modify  | 0.58568    | 0.58568    | 0.58568    |   0.0 |  0.26
Other   |            | 0.08452    |            |       |  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   -13080.424   -13080.424   -13248.345   -13248.345      324.855      324.855    67631.561    67631.561   -827.21279   -827.21279 
    2000   -13096.797   -13096.797   -13261.529   -13261.529    318.68482    318.68482    67434.684    67434.684    500.02231    500.02231 
Loop time of 226.237 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.49     | 225.49     | 225.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092657   | 0.092657   | 0.092657   |   0.0 |  0.04
Output  | 0.00024117 | 0.00024117 | 0.00024117 |   0.0 |  0.00
Modify  | 0.57378    | 0.57378    | 0.57378    |   0.0 |  0.25
Other   |            | 0.08105    |            |       |  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:      224652.0 ave      224652 max      224652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224652
Ave neighs/atom = 56.163000
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   -13096.797   -13096.797   -13261.529   -13261.529    318.68482    318.68482    67434.684    67434.684    500.02231    500.02231 
    3000   -13085.038   -13085.038   -13257.335   -13257.335    333.32004    333.32004     67499.82     67499.82    184.08067    184.08067 
Loop time of 223.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.387 ns/day, 61.949 hours/ns, 4.484 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    | 222.28     | 222.28     | 222.28     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09116    | 0.09116    | 0.09116    |   0.0 |  0.04
Output  | 0.00038525 | 0.00038525 | 0.00038525 |   0.0 |  0.00
Modify  | 0.56008    | 0.56008    | 0.56008    |   0.0 |  0.25
Other   |            | 0.08009    |            |       |  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:      224640.0 ave      224640 max      224640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224640
Ave neighs/atom = 56.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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   -13085.038   -13085.038   -13257.335   -13257.335    333.32004    333.32004     67499.82     67499.82    184.08067    184.08067 
    4000   -13094.702   -13094.702   -13266.289   -13266.289    331.94698    331.94698    67482.007    67482.007   -90.014303   -90.014303 
Loop time of 244.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.353 ns/day, 67.999 hours/ns, 4.085 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    | 243.99     | 243.99     | 243.99     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098715   | 0.098715   | 0.098715   |   0.0 |  0.04
Output  | 0.00022598 | 0.00022598 | 0.00022598 |   0.0 |  0.00
Modify  | 0.61921    | 0.61921    | 0.61921    |   0.0 |  0.25
Other   |            | 0.08686    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5628.00 ave        5628 max        5628 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:      224294.0 ave      224294 max      224294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224294
Ave neighs/atom = 56.073500
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   -13094.702   -13094.702   -13266.289   -13266.289    331.94698    331.94698    67482.007    67482.007   -90.014303   -90.014303 
    5000   -13085.907   -13085.907     -13260.1     -13260.1    336.98723    336.98723    67486.842    67486.842    109.02485    109.02485 
Loop time of 224.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.385 ns/day, 62.404 hours/ns, 4.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 223.91     | 223.91     | 223.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091368   | 0.091368   | 0.091368   |   0.0 |  0.04
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.57262    | 0.57262    | 0.57262    |   0.0 |  0.25
Other   |            | 0.08195    |            |       |  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:      224156.0 ave      224156 max      224156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224156
Ave neighs/atom = 56.039000
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 = 339.66738663038, Press = -38.0532874097017
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   -13085.907   -13085.907     -13260.1     -13260.1    336.98723    336.98723    67486.842    67486.842    109.02485    109.02485 
    6000   -13094.228   -13094.228    -13260.83    -13260.83    322.30295    322.30295    67515.472    67515.472   -239.70092   -239.70092 
Loop time of 233.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.975 hours/ns, 4.275 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    | 233.12     | 233.12     | 233.12     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09442    | 0.09442    | 0.09442    |   0.0 |  0.04
Output  | 0.00036054 | 0.00036054 | 0.00036054 |   0.0 |  0.00
Modify  | 0.60782    | 0.60782    | 0.60782    |   0.0 |  0.26
Other   |            | 0.08277    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5607.00 ave        5607 max        5607 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:      224550.0 ave      224550 max      224550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224550
Ave neighs/atom = 56.137500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974679680044, Press = -5.60247943520326
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   -13094.228   -13094.228    -13260.83    -13260.83    322.30295    322.30295    67515.472    67515.472   -239.70092   -239.70092 
    7000   -13087.511   -13087.511    -13260.71    -13260.71    335.06489    335.06489    67385.077    67385.077    1238.6922    1238.6922 
Loop time of 229.506 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.72     | 228.72     | 228.72     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10154    | 0.10154    | 0.10154    |   0.0 |  0.04
Output  | 0.00014095 | 0.00014095 | 0.00014095 |   0.0 |  0.00
Modify  | 0.60394    | 0.60394    | 0.60394    |   0.0 |  0.26
Other   |            | 0.08389    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5644.00 ave        5644 max        5644 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 = 333.447516577832, Press = 5.44777521226239
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   -13087.511   -13087.511    -13260.71    -13260.71    335.06489    335.06489    67385.077    67385.077    1238.6922    1238.6922 
    8000   -13089.311   -13089.311   -13260.198   -13260.198    330.59386    330.59386     67645.66     67645.66   -1542.2571   -1542.2571 
Loop time of 195.317 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.255 hours/ns, 5.120 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    | 194.65     | 194.65     | 194.65     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080043   | 0.080043   | 0.080043   |   0.0 |  0.04
Output  | 0.0002066  | 0.0002066  | 0.0002066  |   0.0 |  0.00
Modify  | 0.5117     | 0.5117     | 0.5117     |   0.0 |  0.26
Other   |            | 0.07466    |            |       |  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:      224594.0 ave      224594 max      224594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224594
Ave neighs/atom = 56.148500
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 = 333.189304112667, Press = 3.27978702076705
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   -13089.311   -13089.311   -13260.198   -13260.198    330.59386    330.59386     67645.66     67645.66   -1542.2571   -1542.2571 
    9000   -13092.702   -13092.702   -13265.628   -13265.628    334.53806    334.53806    67419.877    67419.877    577.40169    577.40169 
Loop time of 249.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.346 ns/day, 69.405 hours/ns, 4.002 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    | 249.02     | 249.02     | 249.02     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10072    | 0.10072    | 0.10072    |   0.0 |  0.04
Output  | 0.00020929 | 0.00020929 | 0.00020929 |   0.0 |  0.00
Modify  | 0.65179    | 0.65179    | 0.65179    |   0.0 |  0.26
Other   |            | 0.08807    |            |       |  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:      223722.0 ave      223722 max      223722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223722
Ave neighs/atom = 55.930500
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 = 333.690719442017, Press = -7.39192694236926
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   -13092.702   -13092.702   -13265.628   -13265.628    334.53806    334.53806    67419.877    67419.877    577.40169    577.40169 
   10000   -13088.665   -13088.665   -13260.181   -13260.181    331.80974    331.80974    67501.446    67501.446   -20.715247   -20.715247 
Loop time of 231.923 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.373 ns/day, 64.423 hours/ns, 4.312 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.13     | 231.13     | 231.13     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092513   | 0.092513   | 0.092513   |   0.0 |  0.04
Output  | 0.00017243 | 0.00017243 | 0.00017243 |   0.0 |  0.00
Modify  | 0.6124     | 0.6124     | 0.6124     |   0.0 |  0.26
Other   |            | 0.08603    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5617.00 ave        5617 max        5617 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:      224202.0 ave      224202 max      224202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224202
Ave neighs/atom = 56.050500
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 = 333.390403016138, Press = 4.05275202340763
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   -13088.665   -13088.665   -13260.181   -13260.181    331.80974    331.80974    67501.446    67501.446   -20.715247   -20.715247 
   11000   -13093.336   -13093.336   -13263.576   -13263.576    329.34248    329.34248    67493.564    67493.564   -179.11764   -179.11764 
Loop time of 236.429 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.675 hours/ns, 4.230 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.64     | 235.64     | 235.64     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096432   | 0.096432   | 0.096432   |   0.0 |  0.04
Output  | 0.00017716 | 0.00017716 | 0.00017716 |   0.0 |  0.00
Modify  | 0.61052    | 0.61052    | 0.61052    |   0.0 |  0.26
Other   |            | 0.0834     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5679.00 ave        5679 max        5679 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 = 333.003531588959, Press = -1.42229729289801
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 
   11000   -13093.336   -13093.336   -13263.576   -13263.576    329.34248    329.34248    67493.564    67493.564   -179.11764   -179.11764 
   12000   -13089.719   -13089.719   -13263.006   -13263.006    335.23588    335.23588    67470.618    67470.618    156.93686    156.93686 
Loop time of 206.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.433 hours/ns, 4.837 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    | 206.06     | 206.06     | 206.06     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084102   | 0.084102   | 0.084102   |   0.0 |  0.04
Output  | 0.00011236 | 0.00011236 | 0.00011236 |   0.0 |  0.00
Modify  | 0.53476    | 0.53476    | 0.53476    |   0.0 |  0.26
Other   |            | 0.07588    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5622.00 ave        5622 max        5622 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:      224152.0 ave      224152 max      224152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224152
Ave neighs/atom = 56.038000
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 = 332.940511764033, Press = 2.10654469090265
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   -13089.719   -13089.719   -13263.006   -13263.006    335.23588    335.23588    67470.618    67470.618    156.93686    156.93686 
   13000   -13091.233   -13091.233   -13264.267   -13264.267    334.74603    334.74603    67566.414    67566.414   -978.69842   -978.69842 
Loop time of 227.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.217 hours/ns, 4.394 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    | 226.81     | 226.81     | 226.81     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092246   | 0.092246   | 0.092246   |   0.0 |  0.04
Output  | 0.00024025 | 0.00024025 | 0.00024025 |   0.0 |  0.00
Modify  | 0.59152    | 0.59152    | 0.59152    |   0.0 |  0.26
Other   |            | 0.08266    |            |       |  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:      224318.0 ave      224318 max      224318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224318
Ave neighs/atom = 56.079500
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 = 332.704385798444, Press = -4.70992126791653
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   -13091.233   -13091.233   -13264.267   -13264.267    334.74603    334.74603    67566.414    67566.414   -978.69842   -978.69842 
   14000   -13090.056   -13090.056    -13261.22    -13261.22    331.13002    331.13002    67355.039    67355.039    1371.2019    1371.2019 
Loop time of 211.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.707 hours/ns, 4.732 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    | 210.64     | 210.64     | 210.64     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08583    | 0.08583    | 0.08583    |   0.0 |  0.04
Output  | 0.00017853 | 0.00017853 | 0.00017853 |   0.0 |  0.00
Modify  | 0.54569    | 0.54569    | 0.54569    |   0.0 |  0.26
Other   |            | 0.07676    |            |       |  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:      224056.0 ave      224056 max      224056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224056
Ave neighs/atom = 56.014000
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 = 332.670922139722, Press = 3.57764188986335
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 
   14000   -13090.056   -13090.056    -13261.22    -13261.22    331.13002    331.13002    67355.039    67355.039    1371.2019    1371.2019 
   15000    -13090.49    -13090.49   -13259.981   -13259.981    327.89248    327.89248    67580.354    67580.354   -848.87661   -848.87661 
Loop time of 166.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.519 ns/day, 46.238 hours/ns, 6.008 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    | 165.85     | 165.85     | 165.85     |   0.0 | 99.63
Neigh   | 0.039042   | 0.039042   | 0.039042   |   0.0 |  0.02
Comm    | 0.073002   | 0.073002   | 0.073002   |   0.0 |  0.04
Output  | 0.00021903 | 0.00021903 | 0.00021903 |   0.0 |  0.00
Modify  | 0.43286    | 0.43286    | 0.43286    |   0.0 |  0.26
Other   |            | 0.06544    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5674.00 ave        5674 max        5674 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:      224160.0 ave      224160 max      224160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224160
Ave neighs/atom = 56.040000
Neighbor list builds = 1
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 = 332.687568809283, Press = 0.0621699405447765
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    -13090.49    -13090.49   -13259.981   -13259.981    327.89248    327.89248    67580.354    67580.354   -848.87661   -848.87661 
   16000   -13084.405   -13084.405   -13258.344   -13258.344    336.49683    336.49683    67442.084    67442.084    734.62796    734.62796 
Loop time of 227.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.380 ns/day, 63.091 hours/ns, 4.403 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.37     | 226.37     | 226.37     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092039   | 0.092039   | 0.092039   |   0.0 |  0.04
Output  | 0.00017807 | 0.00017807 | 0.00017807 |   0.0 |  0.00
Modify  | 0.58221    | 0.58221    | 0.58221    |   0.0 |  0.26
Other   |            | 0.08005    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5612.00 ave        5612 max        5612 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:      224292.0 ave      224292 max      224292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224292
Ave neighs/atom = 56.073000
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 = 332.922345313484, Press = -1.37385069252405
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   -13084.405   -13084.405   -13258.344   -13258.344    336.49683    336.49683    67442.084    67442.084    734.62796    734.62796 
   17000   -13087.669   -13087.669   -13264.502   -13264.502    342.09397    342.09397    67512.639    67512.639   -285.72404   -285.72404 
Loop time of 226.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.381 ns/day, 62.994 hours/ns, 4.410 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.03     | 226.03     | 226.03     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091735   | 0.091735   | 0.091735   |   0.0 |  0.04
Output  | 0.00017957 | 0.00017957 | 0.00017957 |   0.0 |  0.00
Modify  | 0.5791     | 0.5791     | 0.5791     |   0.0 |  0.26
Other   |            | 0.07999    |            |       |  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:      224662.0 ave      224662 max      224662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224662
Ave neighs/atom = 56.165500
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 = 332.900873463255, Press = 2.43795142602949
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   -13087.669   -13087.669   -13264.502   -13264.502    342.09397    342.09397    67512.639    67512.639   -285.72404   -285.72404 
   18000     -13094.9     -13094.9   -13262.732   -13262.732    324.68316    324.68316    67490.503    67490.503   -70.837956   -70.837956 
Loop time of 219.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.984 hours/ns, 4.555 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.81     | 218.81     | 218.81     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088906   | 0.088906   | 0.088906   |   0.0 |  0.04
Output  | 0.0001771  | 0.0001771  | 0.0001771  |   0.0 |  0.00
Modify  | 0.56306    | 0.56306    | 0.56306    |   0.0 |  0.26
Other   |            | 0.07817    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5616.00 ave        5616 max        5616 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:      224126.0 ave      224126 max      224126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224126
Ave neighs/atom = 56.031500
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 = 332.819053295854, Press = -1.2266951474865
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     -13094.9     -13094.9   -13262.732   -13262.732    324.68316    324.68316    67490.503    67490.503   -70.837956   -70.837956 
   19000   -13088.722   -13088.722    -13262.56    -13262.56    336.30126    336.30126    67449.808    67449.808    418.37675    418.37675 
Loop time of 225.222 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.562 hours/ns, 4.440 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.48     | 224.48     | 224.48     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091623   | 0.091623   | 0.091623   |   0.0 |  0.04
Output  | 0.00018994 | 0.00018994 | 0.00018994 |   0.0 |  0.00
Modify  | 0.57534    | 0.57534    | 0.57534    |   0.0 |  0.26
Other   |            | 0.07942    |            |       |  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:      224272.0 ave      224272 max      224272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224272
Ave neighs/atom = 56.068000
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 = 332.757210264583, Press = 0.734208041405447
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 
   19000   -13088.722   -13088.722    -13262.56    -13262.56    336.30126    336.30126    67449.808    67449.808    418.37675    418.37675 
   20000   -13096.368   -13096.368   -13265.007   -13265.007    326.24282    326.24282    67511.692    67511.692   -407.13077   -407.13077 
Loop time of 221.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.400 hours/ns, 4.524 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    | 220.31     | 220.31     | 220.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.089512   | 0.089512   | 0.089512   |   0.0 |  0.04
Output  | 0.00018949 | 0.00018949 | 0.00018949 |   0.0 |  0.00
Modify  | 0.56418    | 0.56418    | 0.56418    |   0.0 |  0.26
Other   |            | 0.07788    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5620.00 ave        5620 max        5620 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:      224602.0 ave      224602 max      224602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224602
Ave neighs/atom = 56.150500
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 = 332.627189842269, Press = 0.269523992986709
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   -13096.368   -13096.368   -13265.007   -13265.007    326.24282    326.24282    67511.692    67511.692   -407.13077   -407.13077 
   21000   -13090.829   -13090.829   -13264.659   -13264.659    336.28669    336.28669    67428.386    67428.386    484.60232    484.60232 
Loop time of 225.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.752 hours/ns, 4.427 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.16     | 225.16     | 225.16     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092847   | 0.092847   | 0.092847   |   0.0 |  0.04
Output  | 0.00017727 | 0.00017727 | 0.00017727 |   0.0 |  0.00
Modify  | 0.578      | 0.578      | 0.578      |   0.0 |  0.26
Other   |            | 0.07963    |            |       |  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:      224036.0 ave      224036 max      224036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224036
Ave neighs/atom = 56.009000
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 = 332.640496543336, Press = -0.34219113128721
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   -13090.829   -13090.829   -13264.659   -13264.659    336.28669    336.28669    67428.386    67428.386    484.60232    484.60232 
   22000   -13094.379   -13094.379   -13266.572   -13266.572    333.11918    333.11918    67536.571    67536.571   -765.52525   -765.52525 
Loop time of 229.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.377 ns/day, 63.705 hours/ns, 4.360 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.58     | 228.58     | 228.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092524   | 0.092524   | 0.092524   |   0.0 |  0.04
Output  | 0.00018665 | 0.00018665 | 0.00018665 |   0.0 |  0.00
Modify  | 0.58686    | 0.58686    | 0.58686    |   0.0 |  0.26
Other   |            | 0.07994    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5631.00 ave        5631 max        5631 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:      224410.0 ave      224410 max      224410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224410
Ave neighs/atom = 56.102500
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 = 332.631311427878, Press = 1.12836932825528
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 
   22000   -13094.379   -13094.379   -13266.572   -13266.572    333.11918    333.11918    67536.571    67536.571   -765.52525   -765.52525 
   23000   -13088.165   -13088.165   -13263.002   -13263.002    338.23266    338.23266     67447.04     67447.04     421.0801     421.0801 
Loop time of 226.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.382 ns/day, 62.784 hours/ns, 4.424 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.27     | 225.27     | 225.27     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091051   | 0.091051   | 0.091051   |   0.0 |  0.04
Output  | 0.00036435 | 0.00036435 | 0.00036435 |   0.0 |  0.00
Modify  | 0.57859    | 0.57859    | 0.57859    |   0.0 |  0.26
Other   |            | 0.07963    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5652.00 ave        5652 max        5652 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:      224052.0 ave      224052 max      224052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224052
Ave neighs/atom = 56.013000
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 = 332.618700803416, Press = -2.8519870151591
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   -13088.165   -13088.165   -13263.002   -13263.002    338.23266    338.23266     67447.04     67447.04     421.0801     421.0801 
   24000   -13100.084   -13100.084   -13269.742   -13269.742    328.21355    328.21355    67428.784    67428.784    186.92051    186.92051 
Loop time of 224.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.384 ns/day, 62.470 hours/ns, 4.447 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.15     | 224.15     | 224.15     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091254   | 0.091254   | 0.091254   |   0.0 |  0.04
Output  | 0.00017807 | 0.00017807 | 0.00017807 |   0.0 |  0.00
Modify  | 0.57567    | 0.57567    | 0.57567    |   0.0 |  0.26
Other   |            | 0.0802     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5616.00 ave        5616 max        5616 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:      224506.0 ave      224506 max      224506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224506
Ave neighs/atom = 56.126500
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 = 332.553427514446, Press = 2.43283396183743
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   -13100.084   -13100.084   -13269.742   -13269.742    328.21355    328.21355    67428.784    67428.784    186.92051    186.92051 
   25000   -13089.982   -13089.982   -13262.189   -13262.189    333.14612    333.14612    67546.507    67546.507   -631.86891   -631.86891 
Loop time of 234.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.071 hours/ns, 4.269 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.48     | 233.48     | 233.48     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094862   | 0.094862   | 0.094862   |   0.0 |  0.04
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.59725    | 0.59725    | 0.59725    |   0.0 |  0.25
Other   |            | 0.08138    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5696.00 ave        5696 max        5696 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:      224142.0 ave      224142 max      224142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224142
Ave neighs/atom = 56.035500
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 = 332.529726413243, Press = -1.33019717717229
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   -13089.982   -13089.982   -13262.189   -13262.189    333.14612    333.14612    67546.507    67546.507   -631.86891   -631.86891 
   26000   -13092.294   -13092.294   -13262.745   -13262.745    329.74842    329.74842    67392.869    67392.869      961.839      961.839 
Loop time of 173.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.499 ns/day, 48.095 hours/ns, 5.776 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.56     | 172.56     | 172.56     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070519   | 0.070519   | 0.070519   |   0.0 |  0.04
Output  | 0.00017793 | 0.00017793 | 0.00017793 |   0.0 |  0.00
Modify  | 0.45037    | 0.45037    | 0.45037    |   0.0 |  0.26
Other   |            | 0.06689    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5621.00 ave        5621 max        5621 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:      224272.0 ave      224272 max      224272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224272
Ave neighs/atom = 56.068000
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 = 332.542019568809, Press = 1.01611696254183
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   -13092.294   -13092.294   -13262.745   -13262.745    329.74842    329.74842    67392.869    67392.869      961.839      961.839 
   27000   -13087.774   -13087.774   -13262.169   -13262.169    337.37851    337.37851    67590.548    67590.548   -1021.3675   -1021.3675 
Loop time of 153.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.562 ns/day, 42.679 hours/ns, 6.508 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    | 153.12     | 153.12     | 153.12     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063033   | 0.063033   | 0.063033   |   0.0 |  0.04
Output  | 9.942e-05  | 9.942e-05  | 9.942e-05  |   0.0 |  0.00
Modify  | 0.40087    | 0.40087    | 0.40087    |   0.0 |  0.26
Other   |            | 0.0613     |            |       |  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:      224948.0 ave      224948 max      224948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224948
Ave neighs/atom = 56.237000
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 = 332.571621564283, Press = -0.0842140131074114
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 
   27000   -13087.774   -13087.774   -13262.169   -13262.169    337.37851    337.37851    67590.548    67590.548   -1021.3675   -1021.3675 
   28000   -13093.935   -13093.935   -13266.602   -13266.602    334.03614    334.03614    67394.659    67394.659    746.72414    746.72414 
Loop time of 128.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.668 hours/ns, 7.788 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    | 127.96     | 127.96     | 127.96     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052671   | 0.052671   | 0.052671   |   0.0 |  0.04
Output  | 0.00017324 | 0.00017324 | 0.00017324 |   0.0 |  0.00
Modify  | 0.3375     | 0.3375     | 0.3375     |   0.0 |  0.26
Other   |            | 0.05145    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5613.00 ave        5613 max        5613 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:      224166.0 ave      224166 max      224166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224166
Ave neighs/atom = 56.041500
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 = 332.563550552218, Press = -0.2802384796163
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   -13093.935   -13093.935   -13266.602   -13266.602    334.03614    334.03614    67394.659    67394.659    746.72414    746.72414 
   29000   -13086.959   -13086.959   -13261.684   -13261.684    338.01807    338.01807    67528.561    67528.561   -407.26567   -407.26567 
Loop time of 126.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.250 hours/ns, 7.880 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.46     | 126.46     | 126.46     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052526   | 0.052526   | 0.052526   |   0.0 |  0.04
Output  | 9.9836e-05 | 9.9836e-05 | 9.9836e-05 |   0.0 |  0.00
Modify  | 0.33165    | 0.33165    | 0.33165    |   0.0 |  0.26
Other   |            | 0.05072    |            |       |  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:      224528.0 ave      224528 max      224528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224528
Ave neighs/atom = 56.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.561835556371, Press = 0.440925700287497
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   -13086.959   -13086.959   -13261.684   -13261.684    338.01807    338.01807    67528.561    67528.561   -407.26567   -407.26567 
   30000   -13096.378   -13096.378   -13264.532   -13264.532    325.30518    325.30518    67458.882    67458.882    54.679577    54.679577 
Loop time of 125.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.686 ns/day, 34.978 hours/ns, 7.942 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.46     | 125.46     | 125.46     |   0.0 | 99.64
Neigh   | 0.018683   | 0.018683   | 0.018683   |   0.0 |  0.01
Comm    | 0.055236   | 0.055236   | 0.055236   |   0.0 |  0.04
Output  | 9.9627e-05 | 9.9627e-05 | 9.9627e-05 |   0.0 |  0.00
Modify  | 0.33054    | 0.33054    | 0.33054    |   0.0 |  0.26
Other   |            | 0.05054    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5666.00 ave        5666 max        5666 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:      224526.0 ave      224526 max      224526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224526
Ave neighs/atom = 56.131500
Neighbor list builds = 1
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 = 332.511053364244, Press = -0.184636946170163
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   -13096.378   -13096.378   -13264.532   -13264.532    325.30518    325.30518    67458.882    67458.882    54.679577    54.679577 
   31000   -13086.275   -13086.275   -13257.511   -13257.511    331.26763    331.26763     67504.85     67504.85    4.7138979    4.7138979 
Loop time of 126.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.260 hours/ns, 7.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    | 126.5      | 126.5      | 126.5      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052407   | 0.052407   | 0.052407   |   0.0 |  0.04
Output  | 0.00038318 | 0.00038318 | 0.00038318 |   0.0 |  0.00
Modify  | 0.333      | 0.333      | 0.333      |   0.0 |  0.26
Other   |            | 0.05166    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5696.00 ave        5696 max        5696 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:      224128.0 ave      224128 max      224128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224128
Ave neighs/atom = 56.032000
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 = 332.528597978536, Press = 0.319748553972483
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   -13086.275   -13086.275   -13257.511   -13257.511    331.26763    331.26763     67504.85     67504.85    4.7138979    4.7138979 
   32000   -13094.061   -13094.061   -13264.033   -13264.033     328.8219     328.8219    67479.231    67479.231   -24.896861   -24.896861 
Loop time of 117.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.737 ns/day, 32.558 hours/ns, 8.532 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.81     | 116.81     | 116.81     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048153   | 0.048153   | 0.048153   |   0.0 |  0.04
Output  | 0.00010006 | 0.00010006 | 0.00010006 |   0.0 |  0.00
Modify  | 0.30896    | 0.30896    | 0.30896    |   0.0 |  0.26
Other   |            | 0.04806    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5664.00 ave        5664 max        5664 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:      224594.0 ave      224594 max      224594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224594
Ave neighs/atom = 56.148500
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 = 332.549806871213, Press = -0.77653609022362
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   -13094.061   -13094.061   -13264.033   -13264.033     328.8219     328.8219    67479.231    67479.231   -24.896861   -24.896861 
   33000   -13088.328   -13088.328   -13261.677   -13261.677    335.35493    335.35493    67453.483    67453.483    457.01356    457.01356 
Loop time of 113.214 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.448 hours/ns, 8.833 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.82     | 112.82     | 112.82     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046624   | 0.046624   | 0.046624   |   0.0 |  0.04
Output  | 9.9966e-05 | 9.9966e-05 | 9.9966e-05 |   0.0 |  0.00
Modify  | 0.29724    | 0.29724    | 0.29724    |   0.0 |  0.26
Other   |            | 0.04535    |            |       |  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:      224018.0 ave      224018 max      224018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224018
Ave neighs/atom = 56.004500
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 = 332.519740944546, Press = 1.41512325125859
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 
   33000   -13088.328   -13088.328   -13261.677   -13261.677    335.35493    335.35493    67453.483    67453.483    457.01356    457.01356 
   34000    -13095.41    -13095.41   -13263.766   -13263.766    325.69661    325.69661    67554.731    67554.731   -804.34897   -804.34897 
Loop time of 135.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.638 ns/day, 37.642 hours/ns, 7.380 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.04     | 135.04     | 135.04     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055505   | 0.055505   | 0.055505   |   0.0 |  0.04
Output  | 0.00020434 | 0.00020434 | 0.00020434 |   0.0 |  0.00
Modify  | 0.35587    | 0.35587    | 0.35587    |   0.0 |  0.26
Other   |            | 0.05524    |            |       |  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:      224462.0 ave      224462 max      224462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224462
Ave neighs/atom = 56.115500
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 = 332.516848895903, Press = -1.33259219900544
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    -13095.41    -13095.41   -13263.766   -13263.766    325.69661    325.69661    67554.731    67554.731   -804.34897   -804.34897 
   35000   -13086.851   -13086.851   -13259.387   -13259.387    333.78199    333.78199     67410.93     67410.93    990.35948    990.35948 
Loop time of 124.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.696 ns/day, 34.474 hours/ns, 8.058 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    | 123.67     | 123.67     | 123.67     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051608   | 0.051608   | 0.051608   |   0.0 |  0.04
Output  | 0.0001029  | 0.0001029  | 0.0001029  |   0.0 |  0.00
Modify  | 0.33116    | 0.33116    | 0.33116    |   0.0 |  0.27
Other   |            | 0.05204    |            |       |  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:      223914.0 ave      223914 max      223914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223914
Ave neighs/atom = 55.978500
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 = 332.511197675111, Press = 0.412664937223385
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 
   35000   -13086.851   -13086.851   -13259.387   -13259.387    333.78199    333.78199     67410.93     67410.93    990.35948    990.35948 
   36000   -13092.061   -13092.061    -13263.44    -13263.44    331.54325    331.54325    67529.298    67529.298   -584.91148   -584.91148 
Loop time of 137.999 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.626 ns/day, 38.333 hours/ns, 7.246 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    | 137.52     | 137.52     | 137.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0567     | 0.0567     | 0.0567     |   0.0 |  0.04
Output  | 0.0003174  | 0.0003174  | 0.0003174  |   0.0 |  0.00
Modify  | 0.3656     | 0.3656     | 0.3656     |   0.0 |  0.26
Other   |            | 0.05653    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5612.00 ave        5612 max        5612 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:      224886.0 ave      224886 max      224886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224886
Ave neighs/atom = 56.221500
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 = 332.560956421132, Press = 0.0282122741512132
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   -13092.061   -13092.061    -13263.44    -13263.44    331.54325    331.54325    67529.298    67529.298   -584.91148   -584.91148 
   37000   -13087.328   -13087.328   -13261.877   -13261.877     337.6779     337.6779     67446.12     67446.12    404.55659    404.55659 
Loop time of 115.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.747 ns/day, 32.117 hours/ns, 8.649 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.22     | 115.22     | 115.22     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04805    | 0.04805    | 0.04805    |   0.0 |  0.04
Output  | 0.00024645 | 0.00024645 | 0.00024645 |   0.0 |  0.00
Modify  | 0.30738    | 0.30738    | 0.30738    |   0.0 |  0.27
Other   |            | 0.04846    |            |       |  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:      224098.0 ave      224098 max      224098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224098
Ave neighs/atom = 56.024500
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 = 332.616672877356, Press = -0.233183341174319
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 
   37000   -13087.328   -13087.328   -13261.877   -13261.877     337.6779     337.6779     67446.12     67446.12    404.55659    404.55659 
   38000   -13084.595   -13084.595   -13258.202   -13258.202    335.85544    335.85544    67539.634    67539.634   -371.17359   -371.17359 
Loop time of 114.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.939 hours/ns, 8.697 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.58     | 114.58     | 114.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047764   | 0.047764   | 0.047764   |   0.0 |  0.04
Output  | 0.00012858 | 0.00012858 | 0.00012858 |   0.0 |  0.00
Modify  | 0.30669    | 0.30669    | 0.30669    |   0.0 |  0.27
Other   |            | 0.04832    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5658.00 ave        5658 max        5658 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:      224606.0 ave      224606 max      224606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224606
Ave neighs/atom = 56.151500
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 = 332.637273390217, Press = 0.387881140953052
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 
   38000   -13084.595   -13084.595   -13258.202   -13258.202    335.85544    335.85544    67539.634    67539.634   -371.17359   -371.17359 
   39000   -13092.169   -13092.169   -13263.616   -13263.616    331.67468    331.67468    67447.948    67447.948      276.785      276.785 
Loop time of 132.722 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.651 ns/day, 36.867 hours/ns, 7.535 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    | 132.26     | 132.26     | 132.26     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054502   | 0.054502   | 0.054502   |   0.0 |  0.04
Output  | 0.00029076 | 0.00029076 | 0.00029076 |   0.0 |  0.00
Modify  | 0.35351    | 0.35351    | 0.35351    |   0.0 |  0.27
Other   |            | 0.05635    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5599.00 ave        5599 max        5599 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:      224432.0 ave      224432 max      224432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224432
Ave neighs/atom = 56.108000
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 = 332.694587610169, Press = -1.90276151425692
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   -13092.169   -13092.169   -13263.616   -13263.616    331.67468    331.67468    67447.948    67447.948      276.785      276.785 
   40000    -13085.65    -13085.65   -13263.012   -13263.012    343.11962    343.11962    67453.103    67453.103    385.27976    385.27976 
Loop time of 141.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.609 ns/day, 39.429 hours/ns, 7.045 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    | 141.45     | 141.45     | 141.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058712   | 0.058712   | 0.058712   |   0.0 |  0.04
Output  | 0.00020933 | 0.00020933 | 0.00020933 |   0.0 |  0.00
Modify  | 0.37434    | 0.37434    | 0.37434    |   0.0 |  0.26
Other   |            | 0.05724    |            |       |  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:      224478.0 ave      224478 max      224478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224478
Ave neighs/atom = 56.119500
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 = 332.740815644314, Press = 1.55885361147833
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    -13085.65    -13085.65   -13263.012   -13263.012    343.11962    343.11962    67453.103    67453.103    385.27976    385.27976 
   41000   -13089.095   -13089.095   -13259.948   -13259.948    330.52661    330.52661    67536.263    67536.263   -415.63609   -415.63609 
Loop time of 147.363 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.586 ns/day, 40.934 hours/ns, 6.786 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    | 146.85     | 146.85     | 146.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060103   | 0.060103   | 0.060103   |   0.0 |  0.04
Output  | 0.00011589 | 0.00011589 | 0.00011589 |   0.0 |  0.00
Modify  | 0.38839    | 0.38839    | 0.38839    |   0.0 |  0.26
Other   |            | 0.06041    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5598.00 ave        5598 max        5598 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:      224792.0 ave      224792 max      224792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224792
Ave neighs/atom = 56.198000
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 = 332.723400554249, Press = -0.538767451464872
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 
   41000   -13089.095   -13089.095   -13259.948   -13259.948    330.52661    330.52661    67536.263    67536.263   -415.63609   -415.63609 
   42000   -13097.273   -13097.273   -13265.954   -13265.954    326.32419    326.32419    67408.734    67408.734    586.00704    586.00704 
Loop time of 133.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.648 ns/day, 37.060 hours/ns, 7.495 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    | 132.95     | 132.95     | 132.95     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05539    | 0.05539    | 0.05539    |   0.0 |  0.04
Output  | 9.8812e-05 | 9.8812e-05 | 9.8812e-05 |   0.0 |  0.00
Modify  | 0.35497    | 0.35497    | 0.35497    |   0.0 |  0.27
Other   |            | 0.05737    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5651.00 ave        5651 max        5651 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:      224346.0 ave      224346 max      224346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224346
Ave neighs/atom = 56.086500
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 = 332.710519537078, Press = 0.196398982883554
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   -13097.273   -13097.273   -13265.954   -13265.954    326.32419    326.32419    67408.734    67408.734    586.00704    586.00704 
   43000     -13088.5     -13088.5   -13260.103   -13260.103    331.97617    331.97617    67544.753    67544.753   -474.38848   -474.38848 
Loop time of 212.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.105 hours/ns, 4.700 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    | 212.05     | 212.05     | 212.05     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085898   | 0.085898   | 0.085898   |   0.0 |  0.04
Output  | 0.00035253 | 0.00035253 | 0.00035253 |   0.0 |  0.00
Modify  | 0.55664    | 0.55664    | 0.55664    |   0.0 |  0.26
Other   |            | 0.0815     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5644.00 ave        5644 max        5644 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:      224400.0 ave      224400 max      224400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224400
Ave neighs/atom = 56.100000
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 = 332.682029662303, Press = 0.0850397546813992
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     -13088.5     -13088.5   -13260.103   -13260.103    331.97617    331.97617    67544.753    67544.753   -474.38848   -474.38848 
   44000   -13095.111   -13095.111   -13262.391   -13262.391    323.61585    323.61585    67368.993    67368.993    1114.2168    1114.2168 
Loop time of 207.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.682 hours/ns, 4.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    | 206.96     | 206.96     | 206.96     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084277   | 0.084277   | 0.084277   |   0.0 |  0.04
Output  | 0.00048376 | 0.00048376 | 0.00048376 |   0.0 |  0.00
Modify  | 0.53688    | 0.53688    | 0.53688    |   0.0 |  0.26
Other   |            | 0.07675    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5665.00 ave        5665 max        5665 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:      224314.0 ave      224314 max      224314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224314
Ave neighs/atom = 56.078500
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 = 332.652210160864, Press = -0.318507493751136
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 
   44000   -13095.111   -13095.111   -13262.391   -13262.391    323.61585    323.61585    67368.993    67368.993    1114.2168    1114.2168 
   45000    -13090.96    -13090.96   -13261.783   -13261.783    330.46831    330.46831    67582.731    67582.731   -1031.3512   -1031.3512 
Loop time of 199.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.551 hours/ns, 5.000 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    | 199.31     | 199.31     | 199.31     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08121    | 0.08121    | 0.08121    |   0.0 |  0.04
Output  | 0.00020585 | 0.00020585 | 0.00020585 |   0.0 |  0.00
Modify  | 0.52001    | 0.52001    | 0.52001    |   0.0 |  0.26
Other   |            | 0.0773     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5645.00 ave        5645 max        5645 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:      224756.0 ave      224756 max      224756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224756
Ave neighs/atom = 56.189000
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 = 332.681490495606, Press = 0.968971113500099
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 
   45000    -13090.96    -13090.96   -13261.783   -13261.783    330.46831    330.46831    67582.731    67582.731   -1031.3512   -1031.3512 
   46000   -13087.576   -13087.576   -13259.362   -13259.362    332.33073    332.33073    67462.241    67462.241    353.85666    353.85666 
Loop time of 218.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.565 hours/ns, 4.586 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    | 217.31     | 217.31     | 217.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.088252   | 0.088252   | 0.088252   |   0.0 |  0.04
Output  | 0.00018061 | 0.00018061 | 0.00018061 |   0.0 |  0.00
Modify  | 0.56168    | 0.56168    | 0.56168    |   0.0 |  0.26
Other   |            | 0.07826    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5633.00 ave        5633 max        5633 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:      224206.0 ave      224206 max      224206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224206
Ave neighs/atom = 56.051500
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 = 332.717716310829, Press = -0.869212771302644
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   -13087.576   -13087.576   -13259.362   -13259.362    332.33073    332.33073    67462.241    67462.241    353.85666    353.85666 
   47000    -13088.92    -13088.92   -13261.646   -13261.646    334.14955    334.14955    67455.723    67455.723    331.11566    331.11566 
Loop time of 219.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.393 ns/day, 61.042 hours/ns, 4.551 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.02     | 219.02     | 219.02     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087782   | 0.087782   | 0.087782   |   0.0 |  0.04
Output  | 0.00020883 | 0.00020883 | 0.00020883 |   0.0 |  0.00
Modify  | 0.56377    | 0.56377    | 0.56377    |   0.0 |  0.26
Other   |            | 0.07791    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5554.00 ave        5554 max        5554 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:      224890.0 ave      224890 max      224890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224890
Ave neighs/atom = 56.222500
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 = 332.791828648126, Press = 0.515787659732902
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    -13088.92    -13088.92   -13261.646   -13261.646    334.14955    334.14955    67455.723    67455.723    331.11566    331.11566 
   48000   -13088.194   -13088.194   -13259.695   -13259.695    331.78158    331.78158    67524.164    67524.164   -338.67542   -338.67542 
Loop time of 213.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.407 hours/ns, 4.676 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    | 213.15     | 213.15     | 213.15     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.087199   | 0.087199   | 0.087199   |   0.0 |  0.04
Output  | 0.00017609 | 0.00017609 | 0.00017609 |   0.0 |  0.00
Modify  | 0.55058    | 0.55058    | 0.55058    |   0.0 |  0.26
Other   |            | 0.07734    |            |       |  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:      224656.0 ave      224656 max      224656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224656
Ave neighs/atom = 56.164000
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 = 332.798964932667, Press = -0.371377921599008
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 
   48000   -13088.194   -13088.194   -13259.695   -13259.695    331.78158    331.78158    67524.164    67524.164   -338.67542   -338.67542 
   49000   -13092.429   -13092.429   -13264.602   -13264.602    333.07934    333.07934    67398.984    67398.984    763.73677    763.73677 
Loop time of 228.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.378 ns/day, 63.563 hours/ns, 4.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.07     | 228.07     | 228.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092669   | 0.092669   | 0.092669   |   0.0 |  0.04
Output  | 0.00017984 | 0.00017984 | 0.00017984 |   0.0 |  0.00
Modify  | 0.58494    | 0.58494    | 0.58494    |   0.0 |  0.26
Other   |            | 0.07978    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5584.00 ave        5584 max        5584 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:      224614.0 ave      224614 max      224614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224614
Ave neighs/atom = 56.153500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.829261199618, Press = 0.360224671958709
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   -13092.429   -13092.429   -13264.602   -13264.602    333.07934    333.07934    67398.984    67398.984    763.73677    763.73677 
   50000   -13091.254   -13091.254     -13260.5     -13260.5    327.41795    327.41795     67668.96     67668.96   -1916.3766   -1916.3766 
Loop time of 234.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 65.121 hours/ns, 4.266 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.66     | 233.66     | 233.66     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094997   | 0.094997   | 0.094997   |   0.0 |  0.04
Output  | 0.0001717  | 0.0001717  | 0.0001717  |   0.0 |  0.00
Modify  | 0.59741    | 0.59741    | 0.59741    |   0.0 |  0.25
Other   |            | 0.08082    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5663.00 ave        5663 max        5663 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:      224808.0 ave      224808 max      224808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224808
Ave neighs/atom = 56.202000
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 = 332.852285095778, Press = 0.00460027128701692
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 
   50000   -13091.254   -13091.254     -13260.5     -13260.5    327.41795    327.41795     67668.96     67668.96   -1916.3766   -1916.3766 
   51000   -13089.242   -13089.242   -13260.304   -13260.304    330.93015    330.93015    67399.229    67399.229    955.17983    955.17983 
Loop time of 181.96 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.475 ns/day, 50.544 hours/ns, 5.496 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.35     | 181.35     | 181.35     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0729     | 0.0729     | 0.0729     |   0.0 |  0.04
Output  | 0.00024893 | 0.00024893 | 0.00024893 |   0.0 |  0.00
Modify  | 0.471      | 0.471      | 0.471      |   0.0 |  0.26
Other   |            | 0.06927    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5541.00 ave        5541 max        5541 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:      224130.0 ave      224130 max      224130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224130
Ave neighs/atom = 56.032500
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 = 332.875282701494, Press = -0.282196320184041
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   -13089.242   -13089.242   -13260.304   -13260.304    330.93015    330.93015    67399.229    67399.229    955.17983    955.17983 
   52000   -13095.599   -13095.599   -13265.211   -13265.211    328.12418    328.12418    67496.354    67496.354   -319.25326   -319.25326 
Loop time of 118.657 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.728 ns/day, 32.960 hours/ns, 8.428 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.24     | 118.24     | 118.24     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04891    | 0.04891    | 0.04891    |   0.0 |  0.04
Output  | 9.4421e-05 | 9.4421e-05 | 9.4421e-05 |   0.0 |  0.00
Modify  | 0.31592    | 0.31592    | 0.31592    |   0.0 |  0.27
Other   |            | 0.0489     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5673.00 ave        5673 max        5673 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:      224930.0 ave      224930 max      224930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224930
Ave neighs/atom = 56.232500
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 = 332.832630529328, Press = 0.499698152450024
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 
   52000   -13095.599   -13095.599   -13265.211   -13265.211    328.12418    328.12418    67496.354    67496.354   -319.25326   -319.25326 
   53000   -13091.133   -13091.133   -13262.727   -13262.727    331.96037    331.96037    67496.801    67496.801   -141.07993   -141.07993 
Loop time of 113.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.762 ns/day, 31.516 hours/ns, 8.814 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.06     | 113.06     | 113.06     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046824   | 0.046824   | 0.046824   |   0.0 |  0.04
Output  | 0.00017138 | 0.00017138 | 0.00017138 |   0.0 |  0.00
Modify  | 0.30198    | 0.30198    | 0.30198    |   0.0 |  0.27
Other   |            | 0.04778    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5607.00 ave        5607 max        5607 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:      224182.0 ave      224182 max      224182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224182
Ave neighs/atom = 56.045500
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 = 332.842163185992, Press = -0.437184850479213
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   -13091.133   -13091.133   -13262.727   -13262.727    331.96037    331.96037    67496.801    67496.801   -141.07993   -141.07993 
   54000   -13088.206   -13088.206   -13260.393   -13260.393    333.10827    333.10827    67454.012    67454.012    405.41096    405.41096 
Loop time of 113.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.430 hours/ns, 8.838 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.75     | 112.75     | 112.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046447   | 0.046447   | 0.046447   |   0.0 |  0.04
Output  | 0.00010364 | 0.00010364 | 0.00010364 |   0.0 |  0.00
Modify  | 0.29937    | 0.29937    | 0.29937    |   0.0 |  0.26
Other   |            | 0.04676    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5651.00 ave        5651 max        5651 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:      224308.0 ave      224308 max      224308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224308
Ave neighs/atom = 56.077000
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 = 332.830108044293, Press = 0.568258963478355
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 
   54000   -13088.206   -13088.206   -13260.393   -13260.393    333.10827    333.10827    67454.012    67454.012    405.41096    405.41096 
   55000    -13088.79    -13088.79    -13261.82    -13261.82    334.73857    334.73857    67637.294    67637.294   -1469.1243   -1469.1243 
Loop time of 115.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.747 ns/day, 32.114 hours/ns, 8.650 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.2      | 115.2      | 115.2      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047722   | 0.047722   | 0.047722   |   0.0 |  0.04
Output  | 8.8655e-05 | 8.8655e-05 | 8.8655e-05 |   0.0 |  0.00
Modify  | 0.30868    | 0.30868    | 0.30868    |   0.0 |  0.27
Other   |            | 0.04859    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5634.00 ave        5634 max        5634 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:      224754.0 ave      224754 max      224754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224754
Ave neighs/atom = 56.188500
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 = 332.810000584616, Press = -0.850073208152534
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    -13088.79    -13088.79    -13261.82    -13261.82    334.73857    334.73857    67637.294    67637.294   -1469.1243   -1469.1243 
   56000   -13088.386   -13088.386    -13261.65    -13261.65    335.19024    335.19024    67355.231    67355.231    1479.6259    1479.6259 
Loop time of 120.168 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.719 ns/day, 33.380 hours/ns, 8.322 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    | 119.74     | 119.74     | 119.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050517   | 0.050517   | 0.050517   |   0.0 |  0.04
Output  | 0.00017955 | 0.00017955 | 0.00017955 |   0.0 |  0.00
Modify  | 0.32312    | 0.32312    | 0.32312    |   0.0 |  0.27
Other   |            | 0.0535     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5708.00 ave        5708 max        5708 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:      224024.0 ave      224024 max      224024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224024
Ave neighs/atom = 56.006000
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 = 332.81643262158, Press = 0.308612510092147
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 
   56000   -13088.386   -13088.386    -13261.65    -13261.65    335.19024    335.19024    67355.231    67355.231    1479.6259    1479.6259 
   57000   -13091.492   -13091.492   -13262.271   -13262.271    330.38502    330.38502    67572.005    67572.005   -882.22967   -882.22967 
Loop time of 125.876 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.686 ns/day, 34.965 hours/ns, 7.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    | 125.44     | 125.44     | 125.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052351   | 0.052351   | 0.052351   |   0.0 |  0.04
Output  | 0.0003604  | 0.0003604  | 0.0003604  |   0.0 |  0.00
Modify  | 0.33262    | 0.33262    | 0.33262    |   0.0 |  0.26
Other   |            | 0.05095    |            |       |  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:      225030.0 ave      225030 max      225030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 225030
Ave neighs/atom = 56.257500
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 = 332.863368135574, Press = 0.41173949488586
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   -13091.492   -13091.492   -13262.271   -13262.271    330.38502    330.38502    67572.005    67572.005   -882.22967   -882.22967 
   58000   -13087.471   -13087.471   -13260.645   -13260.645    335.01653    335.01653    67452.853    67452.853     497.7781     497.7781 
Loop time of 116.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.740 ns/day, 32.452 hours/ns, 8.560 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.43     | 116.43     | 116.43     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048433   | 0.048433   | 0.048433   |   0.0 |  0.04
Output  | 0.00010308 | 0.00010308 | 0.00010308 |   0.0 |  0.00
Modify  | 0.30616    | 0.30616    | 0.30616    |   0.0 |  0.26
Other   |            | 0.04564    |            |       |  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:      224058.0 ave      224058 max      224058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224058
Ave neighs/atom = 56.014500
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 = 332.87369252936, Press = -0.395316965250289
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   -13087.471   -13087.471   -13260.645   -13260.645    335.01653    335.01653    67452.853    67452.853     497.7781     497.7781 
   59000   -13091.125   -13091.125   -13264.354   -13264.354    335.12247    335.12247    67487.478    67487.478   -137.94399   -137.94399 
Loop time of 116.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.744 ns/day, 32.239 hours/ns, 8.616 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.67     | 115.67     | 115.67     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047503   | 0.047503   | 0.047503   |   0.0 |  0.04
Output  | 0.00010058 | 0.00010058 | 0.00010058 |   0.0 |  0.00
Modify  | 0.30315    | 0.30315    | 0.30315    |   0.0 |  0.26
Other   |            | 0.04492    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5641.00 ave        5641 max        5641 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:      224774.0 ave      224774 max      224774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224774
Ave neighs/atom = 56.193500
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 = 332.883005501472, Press = 0.460117469320621
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   -13091.125   -13091.125   -13264.354   -13264.354    335.12247    335.12247    67487.478    67487.478   -137.94399   -137.94399 
   60000   -13093.904   -13093.904   -13260.738   -13260.738    322.75044    322.75044    67520.278    67520.278   -290.86337   -290.86337 
Loop time of 119.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.264 hours/ns, 8.351 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    | 119.34     | 119.34     | 119.34     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050073   | 0.050073   | 0.050073   |   0.0 |  0.04
Output  | 0.00011451 | 0.00011451 | 0.00011451 |   0.0 |  0.00
Modify  | 0.31452    | 0.31452    | 0.31452    |   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:        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:      224228.0 ave      224228 max      224228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224228
Ave neighs/atom = 56.057000
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 = 332.905353927101, Press = -0.437389068009019
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 
   60000   -13093.904   -13093.904   -13260.738   -13260.738    322.75044    322.75044    67520.278    67520.278   -290.86337   -290.86337 
   61000   -13088.538   -13088.538   -13261.456   -13261.456    334.52335    334.52335    67324.627    67324.627    1728.6502    1728.6502 
Loop time of 135.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.637 ns/day, 37.680 hours/ns, 7.372 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.18     | 135.18     | 135.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056824   | 0.056824   | 0.056824   |   0.0 |  0.04
Output  | 0.00019227 | 0.00019227 | 0.00019227 |   0.0 |  0.00
Modify  | 0.35729    | 0.35729    | 0.35729    |   0.0 |  0.26
Other   |            | 0.0543     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5621.00 ave        5621 max        5621 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:      224472.0 ave      224472 max      224472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224472
Ave neighs/atom = 56.118000
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 = 332.887892132313, Press = 0.599876049790657
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   -13088.538   -13088.538   -13261.456   -13261.456    334.52335    334.52335    67324.627    67324.627    1728.6502    1728.6502 
   62000   -13096.291   -13096.291    -13266.28    -13266.28    328.85566    328.85566    67567.995    67567.995   -1167.4982   -1167.4982 
Loop time of 128.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.664 hours/ns, 7.789 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    | 127.95     | 127.95     | 127.95     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053139   | 0.053139   | 0.053139   |   0.0 |  0.04
Output  | 0.00010821 | 0.00010821 | 0.00010821 |   0.0 |  0.00
Modify  | 0.33723    | 0.33723    | 0.33723    |   0.0 |  0.26
Other   |            | 0.05044    |            |       |  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:      224948.0 ave      224948 max      224948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224948
Ave neighs/atom = 56.237000
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 = 332.860698953799, Press = -0.00157321296972436
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 
   62000   -13096.291   -13096.291    -13266.28    -13266.28    328.85566    328.85566    67567.995    67567.995   -1167.4982   -1167.4982 
   63000   -13089.014   -13089.014   -13263.031   -13263.031    336.64686    336.64686    67423.896    67423.896    582.82694    582.82694 
Loop time of 119.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.269 hours/ns, 8.350 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    | 119.36     | 119.36     | 119.36     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049567   | 0.049567   | 0.049567   |   0.0 |  0.04
Output  | 0.00010219 | 0.00010219 | 0.00010219 |   0.0 |  0.00
Modify  | 0.31342    | 0.31342    | 0.31342    |   0.0 |  0.26
Other   |            | 0.04667    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5633.00 ave        5633 max        5633 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:      223858.0 ave      223858 max      223858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223858
Ave neighs/atom = 55.964500
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 = 332.842326420446, Press = 0.0754630669198639
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 
   63000   -13089.014   -13089.014   -13263.031   -13263.031    336.64686    336.64686    67423.896    67423.896    582.82694    582.82694 
   64000   -13093.115   -13093.115   -13264.284   -13264.284    331.13768    331.13768    67546.302    67546.302   -788.91062   -788.91062 
Loop time of 125.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.690 ns/day, 34.761 hours/ns, 7.991 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.71     | 124.71     | 124.71     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052097   | 0.052097   | 0.052097   |   0.0 |  0.04
Output  | 0.00010294 | 0.00010294 | 0.00010294 |   0.0 |  0.00
Modify  | 0.32813    | 0.32813    | 0.32813    |   0.0 |  0.26
Other   |            | 0.04891    |            |       |  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:      224740.0 ave      224740 max      224740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224740
Ave neighs/atom = 56.185000
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 = 332.822563327567, Press = 0.239726666147947
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 
   64000   -13093.115   -13093.115   -13264.284   -13264.284    331.13768    331.13768    67546.302    67546.302   -788.91062   -788.91062 
   65000   -13086.627   -13086.627    -13265.21    -13265.21    345.48076    345.48076    67459.505    67459.505    202.07448    202.07448 
Loop time of 120.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.716 ns/day, 33.505 hours/ns, 8.291 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    | 120.2      | 120.2      | 120.2      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049774   | 0.049774   | 0.049774   |   0.0 |  0.04
Output  | 0.00010645 | 0.00010645 | 0.00010645 |   0.0 |  0.00
Modify  | 0.31619    | 0.31619    | 0.31619    |   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:        5627.00 ave        5627 max        5627 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:      224202.0 ave      224202 max      224202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224202
Ave neighs/atom = 56.050500
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 = 332.834324268351, Press = -0.319785114861383
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 
   65000   -13086.627   -13086.627    -13265.21    -13265.21    345.48076    345.48076    67459.505    67459.505    202.07448    202.07448 
   66000   -13091.969   -13091.969   -13261.253   -13261.253    327.49273    327.49273    67480.531    67480.531    85.101349    85.101349 
Loop time of 128.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.649 hours/ns, 7.792 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    | 127.9      | 127.9      | 127.9      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053115   | 0.053115   | 0.053115   |   0.0 |  0.04
Output  | 0.00018732 | 0.00018732 | 0.00018732 |   0.0 |  0.00
Modify  | 0.3384     | 0.3384     | 0.3384     |   0.0 |  0.26
Other   |            | 0.05067    |            |       |  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:      224340.0 ave      224340 max      224340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224340
Ave neighs/atom = 56.085000
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 = 332.85719700127, Press = 1.26556874884808
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 
   66000   -13091.969   -13091.969   -13261.253   -13261.253    327.49273    327.49273    67480.531    67480.531    85.101349    85.101349 
   67000   -13086.803   -13086.803   -13258.392   -13258.392    331.95136    331.95136    67576.594    67576.594   -717.12057   -717.12057 
Loop time of 162.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.532 ns/day, 45.101 hours/ns, 6.159 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    | 161.8      | 161.8      | 161.8      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067775   | 0.067775   | 0.067775   |   0.0 |  0.04
Output  | 0.00017657 | 0.00017657 | 0.00017657 |   0.0 |  0.00
Modify  | 0.42908    | 0.42908    | 0.42908    |   0.0 |  0.26
Other   |            | 0.06508    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5652.00 ave        5652 max        5652 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:      224436.0 ave      224436 max      224436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224436
Ave neighs/atom = 56.109000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879751354679, Press = -0.532459453906886
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 
   67000   -13086.803   -13086.803   -13258.392   -13258.392    331.95136    331.95136    67576.594    67576.594   -717.12057   -717.12057 
   68000   -13089.068   -13089.068   -13263.743   -13263.743    337.91961    337.91961    67423.912    67423.912    680.57948    680.57948 
Loop time of 190.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.454 ns/day, 52.874 hours/ns, 5.254 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.7      | 189.7      | 189.7      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078655   | 0.078655   | 0.078655   |   0.0 |  0.04
Output  | 0.00010052 | 0.00010052 | 0.00010052 |   0.0 |  0.00
Modify  | 0.49801    | 0.49801    | 0.49801    |   0.0 |  0.26
Other   |            | 0.07315    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5652.00 ave        5652 max        5652 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:      224210.0 ave      224210 max      224210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224210
Ave neighs/atom = 56.052500
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 = 332.911109230014, Press = 0.1574399522552
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 
   68000   -13089.068   -13089.068   -13263.743   -13263.743    337.91961    337.91961    67423.912    67423.912    680.57948    680.57948 
   69000   -13086.534   -13086.534    -13261.12    -13261.12    337.74835    337.74835    67559.095    67559.095   -725.56275   -725.56275 
Loop time of 113.192 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.442 hours/ns, 8.835 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.81     | 112.81     | 112.81     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046218   | 0.046218   | 0.046218   |   0.0 |  0.04
Output  | 0.00010149 | 0.00010149 | 0.00010149 |   0.0 |  0.00
Modify  | 0.29471    | 0.29471    | 0.29471    |   0.0 |  0.26
Other   |            | 0.04342    |            |       |  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:      224672.0 ave      224672 max      224672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224672
Ave neighs/atom = 56.168000
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 = 332.925491950176, Press = 0.14295148613008
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 
   69000   -13086.534   -13086.534    -13261.12    -13261.12    337.74835    337.74835    67559.095    67559.095   -725.56275   -725.56275 
   70000   -13091.559   -13091.559   -13261.313   -13261.313    328.40075    328.40075    67417.624    67417.624    783.51378    783.51378 
Loop time of 121.415 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.712 ns/day, 33.726 hours/ns, 8.236 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        | 121        | 121        |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050073   | 0.050073   | 0.050073   |   0.0 |  0.04
Output  | 0.00010113 | 0.00010113 | 0.00010113 |   0.0 |  0.00
Modify  | 0.31633    | 0.31633    | 0.31633    |   0.0 |  0.26
Other   |            | 0.04677    |            |       |  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:      223988.0 ave      223988 max      223988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223988
Ave neighs/atom = 55.997000
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
67485.3870378072

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0