# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.5192944586277033*${_u_distance}
variable latticeconst_converted equal 3.5192944586277033*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.5192944586277
Lattice spacing in x,y,z = 3.5192945 3.5192945 3.5192945
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 (35.192945 35.192945 35.192945)
  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 (35.192945 35.192945 35.192945)
  create_atoms CPU = 0.007 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BonnyTerentyevPasianot_2011_FeNiCr__MO_677715648236_000
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43587.9874368387 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_677715648236_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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17657.775   -17657.775   -17798.969   -17798.969       273.15       273.15    43587.987    43587.987      3459.97      3459.97 
    1000   -17503.483   -17503.483   -17646.568   -17646.568    276.80655    276.80655    43629.951    43629.951   -1194.4878   -1194.4878 
Loop time of 63.9895 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.775 hours/ns, 15.628 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    | 62.997     | 62.997     | 62.997     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20288    | 0.20288    | 0.20288    |   0.0 |  0.32
Output  | 0.00022134 | 0.00022134 | 0.00022134 |   0.0 |  0.00
Modify  | 0.68869    | 0.68869    | 0.68869    |   0.0 |  1.08
Other   |            | 0.1005     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      704000.0 ave      704000 max      704000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 704000
Ave neighs/atom = 176.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17503.483   -17503.483   -17646.568   -17646.568    276.80655    276.80655    43629.951    43629.951   -1194.4878   -1194.4878 
    2000   -17514.329   -17514.329   -17655.457   -17655.457    273.02058    273.02058    43603.285    43603.285   -313.09428   -313.09428 
Loop time of 63.7972 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.354 ns/day, 17.721 hours/ns, 15.675 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    | 62.824     | 62.824     | 62.824     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19817    | 0.19817    | 0.19817    |   0.0 |  0.31
Output  | 0.00021498 | 0.00021498 | 0.00021498 |   0.0 |  0.00
Modify  | 0.67472    | 0.67472    | 0.67472    |   0.0 |  1.06
Other   |            | 0.1005     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696666.0 ave      696666 max      696666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696666
Ave neighs/atom = 174.16650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17514.329   -17514.329   -17655.457   -17655.457    273.02058    273.02058    43603.285    43603.285   -313.09428   -313.09428 
    3000   -17512.444   -17512.444   -17651.787   -17651.787    269.56951    269.56951    43600.463    43600.463   -161.63524   -161.63524 
Loop time of 65.3709 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.322 ns/day, 18.159 hours/ns, 15.297 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    | 64.376     | 64.376     | 64.376     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20086    | 0.20086    | 0.20086    |   0.0 |  0.31
Output  | 0.00020996 | 0.00020996 | 0.00020996 |   0.0 |  0.00
Modify  | 0.69137    | 0.69137    | 0.69137    |   0.0 |  1.06
Other   |            | 0.1024     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697166.0 ave      697166 max      697166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697166
Ave neighs/atom = 174.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17512.444   -17512.444   -17651.787   -17651.787    269.56951    269.56951    43600.463    43600.463   -161.63524   -161.63524 
    4000   -17511.247   -17511.247   -17652.444   -17652.444     273.1542     273.1542    43602.181    43602.181   -462.59612   -462.59612 
Loop time of 64.6888 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.336 ns/day, 17.969 hours/ns, 15.459 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    | 63.71      | 63.71      | 63.71      |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19882    | 0.19882    | 0.19882    |   0.0 |  0.31
Output  | 0.00020983 | 0.00020983 | 0.00020983 |   0.0 |  0.00
Modify  | 0.67842    | 0.67842    | 0.67842    |   0.0 |  1.05
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696844.0 ave      696844 max      696844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696844
Ave neighs/atom = 174.21100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17511.247   -17511.247   -17652.444   -17652.444     273.1542     273.1542    43602.181    43602.181   -462.59612   -462.59612 
    5000   -17513.815   -17513.815   -17647.866   -17647.866    259.33076    259.33076    43597.324    43597.324   -392.12797   -392.12797 
Loop time of 65.4985 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.194 hours/ns, 15.268 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    | 64.497     | 64.497     | 64.497     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20204    | 0.20204    | 0.20204    |   0.0 |  0.31
Output  | 0.00017584 | 0.00017584 | 0.00017584 |   0.0 |  0.00
Modify  | 0.69683    | 0.69683    | 0.69683    |   0.0 |  1.06
Other   |            | 0.1023     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696306.0 ave      696306 max      696306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696306
Ave neighs/atom = 174.07650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.731665571265, Press = -362.092988932265
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17513.815   -17513.815   -17647.866   -17647.866    259.33076    259.33076    43597.324    43597.324   -392.12797   -392.12797 
    6000   -17509.726   -17509.726   -17648.849   -17648.849    269.14396    269.14396    43620.608    43620.608   -1037.2086   -1037.2086 
Loop time of 64.5006 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.917 hours/ns, 15.504 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    | 63.507     | 63.507     | 63.507     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19745    | 0.19745    | 0.19745    |   0.0 |  0.31
Output  | 0.00017313 | 0.00017313 | 0.00017313 |   0.0 |  0.00
Modify  | 0.69489    | 0.69489    | 0.69489    |   0.0 |  1.08
Other   |            | 0.1014     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696928.0 ave      696928 max      696928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696928
Ave neighs/atom = 174.23200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.839941796713, Press = -27.301373364065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17509.726   -17509.726   -17648.849   -17648.849    269.14396    269.14396    43620.608    43620.608   -1037.2086   -1037.2086 
    7000   -17513.864   -17513.864   -17659.603   -17659.603    281.94084    281.94084    43644.279    43644.279   -1692.0368   -1692.0368 
Loop time of 65.0924 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.327 ns/day, 18.081 hours/ns, 15.363 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    | 64.081     | 64.081     | 64.081     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20033    | 0.20033    | 0.20033    |   0.0 |  0.31
Output  | 0.00017798 | 0.00017798 | 0.00017798 |   0.0 |  0.00
Modify  | 0.70975    | 0.70975    | 0.70975    |   0.0 |  1.09
Other   |            | 0.1013     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696386.0 ave      696386 max      696386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696386
Ave neighs/atom = 174.09650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.047136429566, Press = -15.8076402940133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17513.864   -17513.864   -17659.603   -17659.603    281.94084    281.94084    43644.279    43644.279   -1692.0368   -1692.0368 
    8000   -17512.164   -17512.164   -17655.321   -17655.321    276.94556    276.94556    43645.356    43645.356   -1797.1209   -1797.1209 
Loop time of 65.1983 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.325 ns/day, 18.111 hours/ns, 15.338 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    | 64.192     | 64.192     | 64.192     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20026    | 0.20026    | 0.20026    |   0.0 |  0.31
Output  | 0.00017487 | 0.00017487 | 0.00017487 |   0.0 |  0.00
Modify  | 0.70457    | 0.70457    | 0.70457    |   0.0 |  1.08
Other   |            | 0.1012     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697970.0 ave      697970 max      697970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697970
Ave neighs/atom = 174.49250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.913007615737, Press = -15.1166224950646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17512.164   -17512.164   -17655.321   -17655.321    276.94556    276.94556    43645.356    43645.356   -1797.1209   -1797.1209 
    9000   -17509.458   -17509.458   -17652.369   -17652.369    276.47024    276.47024    43638.135    43638.135   -1606.6508   -1606.6508 
Loop time of 65.5272 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.202 hours/ns, 15.261 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    | 64.511     | 64.511     | 64.511     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20167    | 0.20167    | 0.20167    |   0.0 |  0.31
Output  | 0.00021911 | 0.00021911 | 0.00021911 |   0.0 |  0.00
Modify  | 0.71218    | 0.71218    | 0.71218    |   0.0 |  1.09
Other   |            | 0.1021     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696620.0 ave      696620 max      696620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696620
Ave neighs/atom = 174.15500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.916788310508, Press = -9.45855777097892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17509.458   -17509.458   -17652.369   -17652.369    276.47024    276.47024    43638.135    43638.135   -1606.6508   -1606.6508 
   10000   -17515.042   -17515.042   -17656.398   -17656.398    273.46339    273.46339    43615.442    43615.442   -788.48033   -788.48033 
Loop time of 64.9822 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.330 ns/day, 18.051 hours/ns, 15.389 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    | 63.981     | 63.981     | 63.981     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19837    | 0.19837    | 0.19837    |   0.0 |  0.31
Output  | 0.0002209  | 0.0002209  | 0.0002209  |   0.0 |  0.00
Modify  | 0.70219    | 0.70219    | 0.70219    |   0.0 |  1.08
Other   |            | 0.1006     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697164.0 ave      697164 max      697164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697164
Ave neighs/atom = 174.29100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.703585138354, Press = -3.66135129970495
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17515.042   -17515.042   -17656.398   -17656.398    273.46339    273.46339    43615.442    43615.442   -788.48033   -788.48033 
   11000   -17511.824   -17511.824   -17647.823   -17647.823    263.09803    263.09803    43606.027    43606.027   -408.15532   -408.15532 
Loop time of 64.5316 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.339 ns/day, 17.925 hours/ns, 15.496 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    | 63.54      | 63.54      | 63.54      |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1966     | 0.1966     | 0.1966     |   0.0 |  0.30
Output  | 0.00017787 | 0.00017787 | 0.00017787 |   0.0 |  0.00
Modify  | 0.69408    | 0.69408    | 0.69408    |   0.0 |  1.08
Other   |            | 0.1006     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697214.0 ave      697214 max      697214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697214
Ave neighs/atom = 174.30350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.655954337533, Press = -2.94203182266773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17511.824   -17511.824   -17647.823   -17647.823    263.09803    263.09803    43606.027    43606.027   -408.15532   -408.15532 
   12000   -17516.355   -17516.355   -17654.642   -17654.642    267.52646    267.52646    43615.396    43615.396   -821.77106   -821.77106 
Loop time of 66.0711 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.308 ns/day, 18.353 hours/ns, 15.135 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    | 65.046     | 65.046     | 65.046     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20285    | 0.20285    | 0.20285    |   0.0 |  0.31
Output  | 0.00017534 | 0.00017534 | 0.00017534 |   0.0 |  0.00
Modify  | 0.72061    | 0.72061    | 0.72061    |   0.0 |  1.09
Other   |            | 0.1014     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696402.0 ave      696402 max      696402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696402
Ave neighs/atom = 174.10050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.495873970504, Press = -3.16052164177554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17516.355   -17516.355   -17654.642   -17654.642    267.52646    267.52646    43615.396    43615.396   -821.77106   -821.77106 
   13000   -17511.455   -17511.455   -17650.615   -17650.615    269.21379    269.21379    43625.654    43625.654   -1293.2643   -1293.2643 
Loop time of 65.5616 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.212 hours/ns, 15.253 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 64.532     | 64.532     | 64.532     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20325    | 0.20325    | 0.20325    |   0.0 |  0.31
Output  | 0.00017083 | 0.00017083 | 0.00017083 |   0.0 |  0.00
Modify  | 0.72411    | 0.72411    | 0.72411    |   0.0 |  1.10
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697112.0 ave      697112 max      697112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697112
Ave neighs/atom = 174.27800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.438211623172, Press = -8.29183255684571
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17511.455   -17511.455   -17650.615   -17650.615    269.21379    269.21379    43625.654    43625.654   -1293.2643   -1293.2643 
   14000    -17517.26    -17517.26   -17656.778   -17656.778    269.90669    269.90669    43618.477    43618.477   -1001.3264   -1001.3264 
Loop time of 65.1077 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.327 ns/day, 18.085 hours/ns, 15.359 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 64.098     | 64.098     | 64.098     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20048    | 0.20048    | 0.20048    |   0.0 |  0.31
Output  | 0.00017758 | 0.00017758 | 0.00017758 |   0.0 |  0.00
Modify  | 0.70734    | 0.70734    | 0.70734    |   0.0 |  1.09
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696616.0 ave      696616 max      696616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696616
Ave neighs/atom = 174.15400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.355804743428, Press = -8.15988428766765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -17517.26    -17517.26   -17656.778   -17656.778    269.90669    269.90669    43618.477    43618.477   -1001.3264   -1001.3264 
   15000   -17512.417   -17512.417   -17652.379   -17652.379    270.76588    270.76588     43610.71     43610.71    -628.5436    -628.5436 
Loop time of 65.7053 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.315 ns/day, 18.251 hours/ns, 15.219 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    | 64.683     | 64.683     | 64.683     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20232    | 0.20232    | 0.20232    |   0.0 |  0.31
Output  | 0.00041365 | 0.00041365 | 0.00041365 |   0.0 |  0.00
Modify  | 0.71718    | 0.71718    | 0.71718    |   0.0 |  1.09
Other   |            | 0.1025     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697324.0 ave      697324 max      697324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697324
Ave neighs/atom = 174.33100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.333878524085, Press = -7.56061132276073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17512.417   -17512.417   -17652.379   -17652.379    270.76588    270.76588     43610.71     43610.71    -628.5436    -628.5436 
   16000   -17519.864   -17519.864   -17660.508   -17660.508    272.08505    272.08505    43591.424    43591.424    147.50628    147.50628 
Loop time of 66.1314 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.306 ns/day, 18.370 hours/ns, 15.121 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    | 65.114     | 65.114     | 65.114     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20242    | 0.20242    | 0.20242    |   0.0 |  0.31
Output  | 0.00017287 | 0.00017287 | 0.00017287 |   0.0 |  0.00
Modify  | 0.71349    | 0.71349    | 0.71349    |   0.0 |  1.08
Other   |            | 0.1013     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696618.0 ave      696618 max      696618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696618
Ave neighs/atom = 174.15450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.316386009622, Press = -4.29346241476337
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17519.864   -17519.864   -17660.508   -17660.508    272.08505    272.08505    43591.424    43591.424    147.50628    147.50628 
   17000   -17509.727   -17509.727   -17653.239   -17653.239    277.63346    277.63346    43593.753    43593.753    147.22908    147.22908 
Loop time of 66.2375 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.304 ns/day, 18.399 hours/ns, 15.097 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    | 65.199     | 65.199     | 65.199     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2048     | 0.2048     | 0.2048     |   0.0 |  0.31
Output  | 0.00017424 | 0.00017424 | 0.00017424 |   0.0 |  0.00
Modify  | 0.732      | 0.732      | 0.732      |   0.0 |  1.11
Other   |            | 0.1018     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      698278.0 ave      698278 max      698278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 698278
Ave neighs/atom = 174.56950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.288390996655, Press = -2.90672523876769
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17509.727   -17509.727   -17653.239   -17653.239    277.63346    277.63346    43593.753    43593.753    147.22908    147.22908 
   18000   -17513.438   -17513.438   -17658.907   -17658.907    281.42057    281.42057    43580.337    43580.337    818.02333    818.02333 
Loop time of 66.5457 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.298 ns/day, 18.485 hours/ns, 15.027 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    | 65.514     | 65.514     | 65.514     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2037     | 0.2037     | 0.2037     |   0.0 |  0.31
Output  | 0.00017296 | 0.00017296 | 0.00017296 |   0.0 |  0.00
Modify  | 0.72634    | 0.72634    | 0.72634    |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697358.0 ave      697358 max      697358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697358
Ave neighs/atom = 174.33950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.311257841005, Press = -3.22458417831549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17513.438   -17513.438   -17658.907   -17658.907    281.42057    281.42057    43580.337    43580.337    818.02333    818.02333 
   19000   -17517.004   -17517.004   -17655.367   -17655.367    267.67352    267.67352    43588.092    43588.092    185.29292    185.29292 
Loop time of 65.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.319 hours/ns, 15.163 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    | 64.92      | 64.92      | 64.92      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20254    | 0.20254    | 0.20254    |   0.0 |  0.31
Output  | 0.00023708 | 0.00023708 | 0.00023708 |   0.0 |  0.00
Modify  | 0.72333    | 0.72333    | 0.72333    |   0.0 |  1.10
Other   |            | 0.1023     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      698440.0 ave      698440 max      698440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 698440
Ave neighs/atom = 174.61000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.334794831827, Press = -1.58682319185322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17517.004   -17517.004   -17655.367   -17655.367    267.67352    267.67352    43588.092    43588.092    185.29292    185.29292 
   20000   -17513.598   -17513.598   -17652.702   -17652.702    269.10745    269.10745    43599.374    43599.374   -307.02559   -307.02559 
Loop time of 65.5466 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.207 hours/ns, 15.256 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    | 64.523     | 64.523     | 64.523     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20167    | 0.20167    | 0.20167    |   0.0 |  0.31
Output  | 0.00017829 | 0.00017829 | 0.00017829 |   0.0 |  0.00
Modify  | 0.72014    | 0.72014    | 0.72014    |   0.0 |  1.10
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697454.0 ave      697454 max      697454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697454
Ave neighs/atom = 174.36350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.332791094721, Press = -1.96237951867884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17513.598   -17513.598   -17652.702   -17652.702    269.10745    269.10745    43599.374    43599.374   -307.02559   -307.02559 
   21000   -17512.729   -17512.729   -17655.054   -17655.054    275.33842    275.33842    43591.049    43591.049    148.80606    148.80606 
Loop time of 64.5488 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.339 ns/day, 17.930 hours/ns, 15.492 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    | 63.541     | 63.541     | 63.541     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19948    | 0.19948    | 0.19948    |   0.0 |  0.31
Output  | 0.00017547 | 0.00017547 | 0.00017547 |   0.0 |  0.00
Modify  | 0.70638    | 0.70638    | 0.70638    |   0.0 |  1.09
Other   |            | 0.1017     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697128.0 ave      697128 max      697128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697128
Ave neighs/atom = 174.28200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.40763037407, Press = -1.07072582582453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17512.729   -17512.729   -17655.054   -17655.054    275.33842    275.33842    43591.049    43591.049    148.80606    148.80606 
   22000   -17515.911   -17515.911   -17654.902   -17654.902    268.88795    268.88795    43581.453    43581.453    377.52377    377.52377 
Loop time of 65.6111 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.225 hours/ns, 15.241 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    | 64.587     | 64.587     | 64.587     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20185    | 0.20185    | 0.20185    |   0.0 |  0.31
Output  | 0.00017577 | 0.00017577 | 0.00017577 |   0.0 |  0.00
Modify  | 0.72029    | 0.72029    | 0.72029    |   0.0 |  1.10
Other   |            | 0.1015     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697648.0 ave      697648 max      697648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697648
Ave neighs/atom = 174.41200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.347810283952, Press = -1.12001130773046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17515.911   -17515.911   -17654.902   -17654.902    268.88795    268.88795    43581.453    43581.453    377.52377    377.52377 
   23000   -17511.139   -17511.139   -17652.041   -17652.041    272.58383    272.58383    43584.039    43584.039     451.8373     451.8373 
Loop time of 65.5592 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.211 hours/ns, 15.253 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 64.542     | 64.542     | 64.542     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20235    | 0.20235    | 0.20235    |   0.0 |  0.31
Output  | 0.00017942 | 0.00017942 | 0.00017942 |   0.0 |  0.00
Modify  | 0.71289    | 0.71289    | 0.71289    |   0.0 |  1.09
Other   |            | 0.1021     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697476.0 ave      697476 max      697476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697476
Ave neighs/atom = 174.36900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.333119340593, Press = -0.967561650459551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17511.139   -17511.139   -17652.041   -17652.041    272.58383    272.58383    43584.039    43584.039     451.8373     451.8373 
   24000   -17518.499   -17518.499   -17656.382   -17656.382    266.74473    266.74473     43569.91     43569.91    829.85214    829.85214 
Loop time of 66.1811 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.306 ns/day, 18.384 hours/ns, 15.110 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    | 65.147     | 65.147     | 65.147     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20465    | 0.20465    | 0.20465    |   0.0 |  0.31
Output  | 0.00017301 | 0.00017301 | 0.00017301 |   0.0 |  0.00
Modify  | 0.7264     | 0.7264     | 0.7264     |   0.0 |  1.10
Other   |            | 0.1027     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697236.0 ave      697236 max      697236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697236
Ave neighs/atom = 174.30900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.305105448062, Press = -1.30488198606347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17518.499   -17518.499   -17656.382   -17656.382    266.74473    266.74473     43569.91     43569.91    829.85214    829.85214 
   25000   -17510.126   -17510.126   -17653.476   -17653.476    277.31894    277.31894     43555.58     43555.58    1569.3412    1569.3412 
Loop time of 65.0061 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.329 ns/day, 18.057 hours/ns, 15.383 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    | 64.003     | 64.003     | 64.003     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19975    | 0.19975    | 0.19975    |   0.0 |  0.31
Output  | 0.00018144 | 0.00018144 | 0.00018144 |   0.0 |  0.00
Modify  | 0.70087    | 0.70087    | 0.70087    |   0.0 |  1.08
Other   |            | 0.1022     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697462.0 ave      697462 max      697462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697462
Ave neighs/atom = 174.36550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.314295171298, Press = -1.17880666750217
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17510.126   -17510.126   -17653.476   -17653.476    277.31894    277.31894     43555.58     43555.58    1569.3412    1569.3412 
   26000   -17513.683   -17513.683   -17651.893   -17651.893    267.37629    267.37629    43538.123    43538.123    2039.5391    2039.5391 
Loop time of 64.879 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.332 ns/day, 18.022 hours/ns, 15.413 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    | 63.879     | 63.879     | 63.879     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1991     | 0.1991     | 0.1991     |   0.0 |  0.31
Output  | 0.00022321 | 0.00022321 | 0.00022321 |   0.0 |  0.00
Modify  | 0.70105    | 0.70105    | 0.70105    |   0.0 |  1.08
Other   |            | 0.1001     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697900.0 ave      697900 max      697900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697900
Ave neighs/atom = 174.47500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.384679580925, Press = -0.524573876629133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17513.683   -17513.683   -17651.893   -17651.893    267.37629    267.37629    43538.123    43538.123    2039.5391    2039.5391 
   27000   -17508.032   -17508.032   -17649.924   -17649.924    274.50131    274.50131    43543.871    43543.871    1954.1189    1954.1189 
Loop time of 65.7847 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.274 hours/ns, 15.201 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    | 64.758     | 64.758     | 64.758     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20318    | 0.20318    | 0.20318    |   0.0 |  0.31
Output  | 0.00017649 | 0.00017649 | 0.00017649 |   0.0 |  0.00
Modify  | 0.72095    | 0.72095    | 0.72095    |   0.0 |  1.10
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697598.0 ave      697598 max      697598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697598
Ave neighs/atom = 174.39950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.470032025411, Press = 0.0344753634440982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17508.032   -17508.032   -17649.924   -17649.924    274.50131    274.50131    43543.871    43543.871    1954.1189    1954.1189 
   28000   -17512.047   -17512.047   -17655.194   -17655.194    276.92769    276.92769    43572.751    43572.751    939.59256    939.59256 
Loop time of 65.2461 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.324 ns/day, 18.124 hours/ns, 15.327 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    | 64.229     | 64.229     | 64.229     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20281    | 0.20281    | 0.20281    |   0.0 |  0.31
Output  | 0.00017626 | 0.00017626 | 0.00017626 |   0.0 |  0.00
Modify  | 0.71201    | 0.71201    | 0.71201    |   0.0 |  1.09
Other   |            | 0.1025     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697976.0 ave      697976 max      697976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697976
Ave neighs/atom = 174.49400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.560655057082, Press = -0.195099571825377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17512.047   -17512.047   -17655.194   -17655.194    276.92769    276.92769    43572.751    43572.751    939.59256    939.59256 
   29000   -17513.975   -17513.975   -17653.983   -17653.983    270.85344    270.85344    43581.412    43581.412    479.00224    479.00224 
Loop time of 64.6022 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.945 hours/ns, 15.479 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    | 63.602     | 63.602     | 63.602     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19879    | 0.19879    | 0.19879    |   0.0 |  0.31
Output  | 0.00022741 | 0.00022741 | 0.00022741 |   0.0 |  0.00
Modify  | 0.69908    | 0.69908    | 0.69908    |   0.0 |  1.08
Other   |            | 0.1017     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697692.0 ave      697692 max      697692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697692
Ave neighs/atom = 174.42300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.537712685136, Press = -0.657062438858425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17513.975   -17513.975   -17653.983   -17653.983    270.85344    270.85344    43581.412    43581.412    479.00224    479.00224 
   30000   -17513.168   -17513.168    -17651.06    -17651.06    266.76146    266.76146    43577.087    43577.087    618.27831    618.27831 
Loop time of 66.3517 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.302 ns/day, 18.431 hours/ns, 15.071 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    | 65.317     | 65.317     | 65.317     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20571    | 0.20571    | 0.20571    |   0.0 |  0.31
Output  | 0.00027361 | 0.00027361 | 0.00027361 |   0.0 |  0.00
Modify  | 0.72673    | 0.72673    | 0.72673    |   0.0 |  1.10
Other   |            | 0.102      |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697272.0 ave      697272 max      697272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697272
Ave neighs/atom = 174.31800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.52221947798, Press = -0.348814918757488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17513.168   -17513.168    -17651.06    -17651.06    266.76146    266.76146    43577.087    43577.087    618.27831    618.27831 
   31000   -17516.644   -17516.644   -17655.459   -17655.459    268.54639    268.54639    43561.337    43561.337    1271.3164    1271.3164 
Loop time of 64.1022 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.348 ns/day, 17.806 hours/ns, 15.600 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    | 63.106     | 63.106     | 63.106     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19908    | 0.19908    | 0.19908    |   0.0 |  0.31
Output  | 0.0001754  | 0.0001754  | 0.0001754  |   0.0 |  0.00
Modify  | 0.69658    | 0.69658    | 0.69658    |   0.0 |  1.09
Other   |            | 0.1002     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697608.0 ave      697608 max      697608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697608
Ave neighs/atom = 174.40200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.500269534353, Press = 0.00547769560551198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17516.644   -17516.644   -17655.459   -17655.459    268.54639    268.54639    43561.337    43561.337    1271.3164    1271.3164 
   32000   -17513.196   -17513.196   -17657.284   -17657.284    278.74822    278.74822     43538.49     43538.49    2309.3658    2309.3658 
Loop time of 64.56 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.338 ns/day, 17.933 hours/ns, 15.489 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    | 63.555     | 63.555     | 63.555     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20138    | 0.20138    | 0.20138    |   0.0 |  0.31
Output  | 0.00018146 | 0.00018146 | 0.00018146 |   0.0 |  0.00
Modify  | 0.70195    | 0.70195    | 0.70195    |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      698004.0 ave      698004 max      698004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 698004
Ave neighs/atom = 174.50100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.500588902772, Press = 0.967079888291992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17513.196   -17513.196   -17657.284   -17657.284    278.74822    278.74822     43538.49     43538.49    2309.3658    2309.3658 
   33000   -17510.417   -17510.417   -17650.496   -17650.496    270.99254    270.99254    43548.314    43548.314    1672.9519    1672.9519 
Loop time of 64.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.349 ns/day, 17.796 hours/ns, 15.609 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    | 63.073     | 63.073     | 63.073     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19784    | 0.19784    | 0.19784    |   0.0 |  0.31
Output  | 0.000177   | 0.000177   | 0.000177   |   0.0 |  0.00
Modify  | 0.69521    | 0.69521    | 0.69521    |   0.0 |  1.09
Other   |            | 0.1012     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      698378.0 ave      698378 max      698378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 698378
Ave neighs/atom = 174.59450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.511826570792, Press = 0.88553166901999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17510.417   -17510.417   -17650.496   -17650.496    270.99254    270.99254    43548.314    43548.314    1672.9519    1672.9519 
   34000   -17512.245   -17512.245   -17652.744   -17652.744    271.80491    271.80491    43577.937    43577.937    636.30334    636.30334 
Loop time of 64.4339 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.341 ns/day, 17.898 hours/ns, 15.520 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    | 63.435     | 63.435     | 63.435     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19747    | 0.19747    | 0.19747    |   0.0 |  0.31
Output  | 0.00021827 | 0.00021827 | 0.00021827 |   0.0 |  0.00
Modify  | 0.7        | 0.7        | 0.7        |   0.0 |  1.09
Other   |            | 0.1014     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697594.0 ave      697594 max      697594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697594
Ave neighs/atom = 174.39850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.499581385107, Press = -0.243270125927378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17512.245   -17512.245   -17652.744   -17652.744    271.80491    271.80491    43577.937    43577.937    636.30334    636.30334 
   35000   -17513.694   -17513.694   -17655.015   -17655.015    273.39457    273.39457     43584.44     43584.44    395.07433    395.07433 
Loop time of 64.0327 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.349 ns/day, 17.787 hours/ns, 15.617 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    | 63.044     | 63.044     | 63.044     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19742    | 0.19742    | 0.19742    |   0.0 |  0.31
Output  | 0.00018157 | 0.00018157 | 0.00018157 |   0.0 |  0.00
Modify  | 0.69029    | 0.69029    | 0.69029    |   0.0 |  1.08
Other   |            | 0.1008     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697464.0 ave      697464 max      697464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697464
Ave neighs/atom = 174.36600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.540753783407, Press = -0.270068714287766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17513.694   -17513.694   -17655.015   -17655.015    273.39457    273.39457     43584.44     43584.44    395.07433    395.07433 
   36000   -17508.912   -17508.912   -17653.506   -17653.506    279.72635    279.72635      43585.1      43585.1    485.12186    485.12186 
Loop time of 63.3991 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.611 hours/ns, 15.773 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    | 62.414     | 62.414     | 62.414     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1962     | 0.1962     | 0.1962     |   0.0 |  0.31
Output  | 0.00017459 | 0.00017459 | 0.00017459 |   0.0 |  0.00
Modify  | 0.68831    | 0.68831    | 0.68831    |   0.0 |  1.09
Other   |            | 0.1005     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697562.0 ave      697562 max      697562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697562
Ave neighs/atom = 174.39050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.607452487745, Press = -0.123579043868579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17508.912   -17508.912   -17653.506   -17653.506    279.72635    279.72635      43585.1      43585.1    485.12186    485.12186 
   37000   -17514.217   -17514.217   -17654.963   -17654.963    272.28376    272.28376    43579.949    43579.949    531.46243    531.46243 
Loop time of 64.7024 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.335 ns/day, 17.973 hours/ns, 15.455 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.697     | 63.697     | 63.697     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20023    | 0.20023    | 0.20023    |   0.0 |  0.31
Output  | 0.0002197  | 0.0002197  | 0.0002197  |   0.0 |  0.00
Modify  | 0.70307    | 0.70307    | 0.70307    |   0.0 |  1.09
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697458.0 ave      697458 max      697458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697458
Ave neighs/atom = 174.36450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633757089435, Press = 0.780073752529394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17514.217   -17514.217   -17654.963   -17654.963    272.28376    272.28376    43579.949    43579.949    531.46243    531.46243 
   38000   -17516.499   -17516.499   -17657.834   -17657.834    273.42093    273.42093    43592.259    43592.259    46.967857    46.967857 
Loop time of 64.012 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.781 hours/ns, 15.622 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    | 63.021     | 63.021     | 63.021     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19724    | 0.19724    | 0.19724    |   0.0 |  0.31
Output  | 0.00021713 | 0.00021713 | 0.00021713 |   0.0 |  0.00
Modify  | 0.69334    | 0.69334    | 0.69334    |   0.0 |  1.08
Other   |            | 0.1006     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697592.0 ave      697592 max      697592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697592
Ave neighs/atom = 174.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.640628725207, Press = 1.29570104152442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17516.499   -17516.499   -17657.834   -17657.834    273.42093    273.42093    43592.259    43592.259    46.967857    46.967857 
   39000   -17512.083   -17512.083   -17653.599   -17653.599    273.77202    273.77202    43606.872    43606.872   -559.55054   -559.55054 
Loop time of 64.4814 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.911 hours/ns, 15.508 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    | 63.475     | 63.475     | 63.475     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20016    | 0.20016    | 0.20016    |   0.0 |  0.31
Output  | 0.00017407 | 0.00017407 | 0.00017407 |   0.0 |  0.00
Modify  | 0.70481    | 0.70481    | 0.70481    |   0.0 |  1.09
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697584.0 ave      697584 max      697584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697584
Ave neighs/atom = 174.39600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.596920802759, Press = 0.657925351316983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17512.083   -17512.083   -17653.599   -17653.599    273.77202    273.77202    43606.872    43606.872   -559.55054   -559.55054 
   40000   -17511.822   -17511.822   -17652.189   -17652.189    271.55005    271.55005    43605.727    43605.727   -449.20149   -449.20149 
Loop time of 64.7852 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.334 ns/day, 17.996 hours/ns, 15.436 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    | 63.771     | 63.771     | 63.771     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20072    | 0.20072    | 0.20072    |   0.0 |  0.31
Output  | 0.00017581 | 0.00017581 | 0.00017581 |   0.0 |  0.00
Modify  | 0.71097    | 0.71097    | 0.71097    |   0.0 |  1.10
Other   |            | 0.1023     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697356.0 ave      697356 max      697356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697356
Ave neighs/atom = 174.33900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.617925841843, Press = 0.0117949077553743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17511.822   -17511.822   -17652.189   -17652.189    271.55005    271.55005    43605.727    43605.727   -449.20149   -449.20149 
   41000   -17513.896   -17513.896   -17654.969   -17654.969    272.91567    272.91567    43607.231    43607.231   -473.17919   -473.17919 
Loop time of 63.7142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.356 ns/day, 17.698 hours/ns, 15.695 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    | 62.72      | 62.72      | 62.72      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19821    | 0.19821    | 0.19821    |   0.0 |  0.31
Output  | 0.00044753 | 0.00044753 | 0.00044753 |   0.0 |  0.00
Modify  | 0.69505    | 0.69505    | 0.69505    |   0.0 |  1.09
Other   |            | 0.1003     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697064.0 ave      697064 max      697064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697064
Ave neighs/atom = 174.26600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.604075410631, Press = 0.0961055271365352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17513.896   -17513.896   -17654.969   -17654.969    272.91567    272.91567    43607.231    43607.231   -473.17919   -473.17919 
   42000   -17510.918   -17510.918   -17650.928   -17650.928    270.85861    270.85861    43615.455    43615.455   -742.23975   -742.23975 
Loop time of 64.2697 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.344 ns/day, 17.853 hours/ns, 15.559 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    | 63.269     | 63.269     | 63.269     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19862    | 0.19862    | 0.19862    |   0.0 |  0.31
Output  | 0.00017419 | 0.00017419 | 0.00017419 |   0.0 |  0.00
Modify  | 0.70006    | 0.70006    | 0.70006    |   0.0 |  1.09
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697094.0 ave      697094 max      697094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697094
Ave neighs/atom = 174.27350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.62072644264, Press = 0.319684332265476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17510.918   -17510.918   -17650.928   -17650.928    270.85861    270.85861    43615.455    43615.455   -742.23975   -742.23975 
   43000    -17511.31    -17511.31   -17655.097   -17655.097    278.16598    278.16598    43628.905    43628.905   -1236.2971   -1236.2971 
Loop time of 63.6399 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.358 ns/day, 17.678 hours/ns, 15.713 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    | 62.65      | 62.65      | 62.65      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19592    | 0.19592    | 0.19592    |   0.0 |  0.31
Output  | 0.0002282  | 0.0002282  | 0.0002282  |   0.0 |  0.00
Modify  | 0.69312    | 0.69312    | 0.69312    |   0.0 |  1.09
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696754.0 ave      696754 max      696754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696754
Ave neighs/atom = 174.18850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.650307510689, Press = 0.363571085698623
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    -17511.31    -17511.31   -17655.097   -17655.097    278.16598    278.16598    43628.905    43628.905   -1236.2971   -1236.2971 
   44000   -17511.185   -17511.185    -17653.15    -17653.15    274.64187    274.64187    43637.637    43637.637   -1598.4998   -1598.4998 
Loop time of 64.3623 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.878 hours/ns, 15.537 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    | 63.358     | 63.358     | 63.358     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19897    | 0.19897    | 0.19897    |   0.0 |  0.31
Output  | 0.00018698 | 0.00018698 | 0.00018698 |   0.0 |  0.00
Modify  | 0.7038     | 0.7038     | 0.7038     |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697424.0 ave      697424 max      697424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697424
Ave neighs/atom = 174.35600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.703729909847, Press = 0.115058383160449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17511.185   -17511.185    -17653.15    -17653.15    274.64187    274.64187    43637.637    43637.637   -1598.4998   -1598.4998 
   45000   -17511.139   -17511.139   -17651.859   -17651.859    272.23228    272.23228    43624.202    43624.202   -1135.0298   -1135.0298 
Loop time of 63.9551 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.351 ns/day, 17.765 hours/ns, 15.636 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    | 62.96      | 62.96      | 62.96      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19691    | 0.19691    | 0.19691    |   0.0 |  0.31
Output  | 0.0001795  | 0.0001795  | 0.0001795  |   0.0 |  0.00
Modify  | 0.69665    | 0.69665    | 0.69665    |   0.0 |  1.09
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696902.0 ave      696902 max      696902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696902
Ave neighs/atom = 174.22550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.737350566119, Press = -0.35596222363498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17511.139   -17511.139   -17651.859   -17651.859    272.23228    272.23228    43624.202    43624.202   -1135.0298   -1135.0298 
   46000   -17513.229   -17513.229   -17653.085   -17653.085    270.56113    270.56113     43634.61     43634.61   -1418.9936   -1418.9936 
Loop time of 63.8407 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.734 hours/ns, 15.664 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    | 62.846     | 62.846     | 62.846     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19943    | 0.19943    | 0.19943    |   0.0 |  0.31
Output  | 0.00022707 | 0.00022707 | 0.00022707 |   0.0 |  0.00
Modify  | 0.69463    | 0.69463    | 0.69463    |   0.0 |  1.09
Other   |            | 0.1006     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696880.0 ave      696880 max      696880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696880
Ave neighs/atom = 174.22000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.790494855196, Press = -0.400364191749123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17513.229   -17513.229   -17653.085   -17653.085    270.56113    270.56113     43634.61     43634.61   -1418.9936   -1418.9936 
   47000   -17509.688   -17509.688   -17651.485   -17651.485    274.31541    274.31541     43624.07     43624.07   -1019.8914   -1019.8914 
Loop time of 64.3214 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.343 ns/day, 17.867 hours/ns, 15.547 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    | 63.32      | 63.32      | 63.32      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19923    | 0.19923    | 0.19923    |   0.0 |  0.31
Output  | 0.00017985 | 0.00017985 | 0.00017985 |   0.0 |  0.00
Modify  | 0.70079    | 0.70079    | 0.70079    |   0.0 |  1.09
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696844.0 ave      696844 max      696844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696844
Ave neighs/atom = 174.21100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.80283080227, Press = -0.649611707386978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17509.688   -17509.688   -17651.485   -17651.485    274.31541    274.31541     43624.07     43624.07   -1019.8914   -1019.8914 
   48000   -17515.596   -17515.596   -17655.757   -17655.757    271.15003    271.15003    43622.347    43622.347   -1043.9447   -1043.9447 
Loop time of 64.2174 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.345 ns/day, 17.838 hours/ns, 15.572 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    | 63.208     | 63.208     | 63.208     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20088    | 0.20088    | 0.20088    |   0.0 |  0.31
Output  | 0.00022679 | 0.00022679 | 0.00022679 |   0.0 |  0.00
Modify  | 0.70663    | 0.70663    | 0.70663    |   0.0 |  1.10
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696544.0 ave      696544 max      696544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696544
Ave neighs/atom = 174.13600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.815842026028, Press = -0.620926455448996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17515.596   -17515.596   -17655.757   -17655.757    271.15003    271.15003    43622.347    43622.347   -1043.9447   -1043.9447 
   49000    -17510.83    -17510.83   -17652.841   -17652.841    274.72947    274.72947    43636.907    43636.907   -1513.5917   -1513.5917 
Loop time of 64.1745 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.346 ns/day, 17.826 hours/ns, 15.583 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    | 63.177     | 63.177     | 63.177     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19811    | 0.19811    | 0.19811    |   0.0 |  0.31
Output  | 0.00017562 | 0.00017562 | 0.00017562 |   0.0 |  0.00
Modify  | 0.69763    | 0.69763    | 0.69763    |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697112.0 ave      697112 max      697112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697112
Ave neighs/atom = 174.27800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.809051171264, Press = -0.945423546228263
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000    -17510.83    -17510.83   -17652.841   -17652.841    274.72947    274.72947    43636.907    43636.907   -1513.5917   -1513.5917 
   50000   -17513.153   -17513.153   -17653.997   -17653.997    272.47125    272.47125    43639.708    43639.708   -1654.3216   -1654.3216 
Loop time of 63.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.356 ns/day, 17.705 hours/ns, 15.689 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    | 62.743     | 62.743     | 62.743     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1982     | 0.1982     | 0.1982     |   0.0 |  0.31
Output  | 0.00018341 | 0.00018341 | 0.00018341 |   0.0 |  0.00
Modify  | 0.69484    | 0.69484    | 0.69484    |   0.0 |  1.09
Other   |            | 0.1004     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696828.0 ave      696828 max      696828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696828
Ave neighs/atom = 174.20700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772303702085, Press = -1.2929584288325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17513.153   -17513.153   -17653.997   -17653.997    272.47125    272.47125    43639.708    43639.708   -1654.3216   -1654.3216 
   51000    -17513.59    -17513.59    -17657.01    -17657.01    277.45647    277.45647    43642.945    43642.945   -1759.1652   -1759.1652 
Loop time of 63.9394 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.351 ns/day, 17.761 hours/ns, 15.640 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    | 62.942     | 62.942     | 62.942     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19825    | 0.19825    | 0.19825    |   0.0 |  0.31
Output  | 0.00017508 | 0.00017508 | 0.00017508 |   0.0 |  0.00
Modify  | 0.69776    | 0.69776    | 0.69776    |   0.0 |  1.09
Other   |            | 0.1008     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696612.0 ave      696612 max      696612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696612
Ave neighs/atom = 174.15300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.773600697481, Press = -1.54817754044403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -17513.59    -17513.59    -17657.01    -17657.01    277.45647    277.45647    43642.945    43642.945   -1759.1652   -1759.1652 
   52000   -17508.205   -17508.205   -17650.728   -17650.728    275.72111    275.72111    43623.745    43623.745   -1039.6843   -1039.6843 
Loop time of 65.2564 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.324 ns/day, 18.127 hours/ns, 15.324 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    | 64.235     | 64.235     | 64.235     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20175    | 0.20175    | 0.20175    |   0.0 |  0.31
Output  | 0.0001757  | 0.0001757  | 0.0001757  |   0.0 |  0.00
Modify  | 0.7169     | 0.7169     | 0.7169     |   0.0 |  1.10
Other   |            | 0.1028     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696896.0 ave      696896 max      696896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696896
Ave neighs/atom = 174.22400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.807517205226, Press = -1.37273215895153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17508.205   -17508.205   -17650.728   -17650.728    275.72111    275.72111    43623.745    43623.745   -1039.6843   -1039.6843 
   53000   -17512.454   -17512.454   -17654.301   -17654.301    274.41338    274.41338    43616.519    43616.519   -771.68328   -771.68328 
Loop time of 64.1283 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.347 ns/day, 17.813 hours/ns, 15.594 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    | 63.127     | 63.127     | 63.127     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19908    | 0.19908    | 0.19908    |   0.0 |  0.31
Output  | 0.00022735 | 0.00022735 | 0.00022735 |   0.0 |  0.00
Modify  | 0.69971    | 0.69971    | 0.69971    |   0.0 |  1.09
Other   |            | 0.1022     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696684.0 ave      696684 max      696684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696684
Ave neighs/atom = 174.17100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.823465151173, Press = -1.03161373461919
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17512.454   -17512.454   -17654.301   -17654.301    274.41338    274.41338    43616.519    43616.519   -771.68328   -771.68328 
   54000   -17508.067   -17508.067   -17651.172   -17651.172    276.84752    276.84752    43601.789    43601.789   -110.20798   -110.20798 
Loop time of 65.2079 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.325 ns/day, 18.113 hours/ns, 15.336 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    | 64.183     | 64.183     | 64.183     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20285    | 0.20285    | 0.20285    |   0.0 |  0.31
Output  | 0.00018063 | 0.00018063 | 0.00018063 |   0.0 |  0.00
Modify  | 0.71946    | 0.71946    | 0.71946    |   0.0 |  1.10
Other   |            | 0.1021     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697282.0 ave      697282 max      697282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697282
Ave neighs/atom = 174.32050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.864225140615, Press = -0.641467899555735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17508.067   -17508.067   -17651.172   -17651.172    276.84752    276.84752    43601.789    43601.789   -110.20798   -110.20798 
   55000   -17513.511   -17513.511   -17654.572   -17654.572    272.89291    272.89291    43612.202    43612.202   -594.39878   -594.39878 
Loop time of 64.7949 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.333 ns/day, 17.999 hours/ns, 15.433 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    | 63.78      | 63.78      | 63.78      |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20158    | 0.20158    | 0.20158    |   0.0 |  0.31
Output  | 0.00018551 | 0.00018551 | 0.00018551 |   0.0 |  0.00
Modify  | 0.71167    | 0.71167    | 0.71167    |   0.0 |  1.10
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697038.0 ave      697038 max      697038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697038
Ave neighs/atom = 174.25950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.887612387977, Press = -0.579229333382191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17513.511   -17513.511   -17654.572   -17654.572    272.89291    272.89291    43612.202    43612.202   -594.39878   -594.39878 
   56000   -17508.895   -17508.895   -17650.668   -17650.668    274.26901    274.26901    43612.903    43612.903   -545.48756   -545.48756 
Loop time of 63.8615 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.739 hours/ns, 15.659 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    | 62.865     | 62.865     | 62.865     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19794    | 0.19794    | 0.19794    |   0.0 |  0.31
Output  | 0.00017906 | 0.00017906 | 0.00017906 |   0.0 |  0.00
Modify  | 0.6976     | 0.6976     | 0.6976     |   0.0 |  1.09
Other   |            | 0.1013     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697166.0 ave      697166 max      697166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697166
Ave neighs/atom = 174.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.914551110854, Press = -0.878061243346556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17508.895   -17508.895   -17650.668   -17650.668    274.26901    274.26901    43612.903    43612.903   -545.48756   -545.48756 
   57000   -17515.586   -17515.586     -17656.9     -17656.9    273.38283    273.38283    43623.913    43623.913   -1097.7428   -1097.7428 
Loop time of 64.6388 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.955 hours/ns, 15.471 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    | 63.626     | 63.626     | 63.626     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20039    | 0.20039    | 0.20039    |   0.0 |  0.31
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.71069    | 0.71069    | 0.71069    |   0.0 |  1.10
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696756.0 ave      696756 max      696756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696756
Ave neighs/atom = 174.18900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918809611725, Press = -1.18901397509646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17515.586   -17515.586     -17656.9     -17656.9    273.38283    273.38283    43623.913    43623.913   -1097.7428   -1097.7428 
   58000   -17511.084   -17511.084   -17652.753   -17652.753    274.06702    274.06702    43633.716    43633.716   -1373.2955   -1373.2955 
Loop time of 64.7609 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.334 ns/day, 17.989 hours/ns, 15.441 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    | 63.752     | 63.752     | 63.752     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20037    | 0.20037    | 0.20037    |   0.0 |  0.31
Output  | 0.00017375 | 0.00017375 | 0.00017375 |   0.0 |  0.00
Modify  | 0.70648    | 0.70648    | 0.70648    |   0.0 |  1.09
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697254.0 ave      697254 max      697254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697254
Ave neighs/atom = 174.31350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.895093638798, Press = -1.53296255627255
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17511.084   -17511.084   -17652.753   -17652.753    274.06702    274.06702    43633.716    43633.716   -1373.2955   -1373.2955 
   59000   -17513.481   -17513.481   -17653.939   -17653.939    271.72548    271.72548     43611.65     43611.65   -505.48817   -505.48817 
Loop time of 64.5993 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.944 hours/ns, 15.480 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    | 63.592     | 63.592     | 63.592     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20052    | 0.20052    | 0.20052    |   0.0 |  0.31
Output  | 0.00017698 | 0.00017698 | 0.00017698 |   0.0 |  0.00
Modify  | 0.70434    | 0.70434    | 0.70434    |   0.0 |  1.09
Other   |            | 0.1024     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696938.0 ave      696938 max      696938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696938
Ave neighs/atom = 174.23450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.914579266706, Press = -1.32158684031643
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17513.481   -17513.481   -17653.939   -17653.939    271.72548    271.72548     43611.65     43611.65   -505.48817   -505.48817 
   60000   -17508.285   -17508.285   -17649.414   -17649.414    273.02299    273.02299    43599.878    43599.878   -57.232784   -57.232784 
Loop time of 64.6423 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.956 hours/ns, 15.470 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    | 63.641     | 63.641     | 63.641     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20064    | 0.20064    | 0.20064    |   0.0 |  0.31
Output  | 0.00017698 | 0.00017698 | 0.00017698 |   0.0 |  0.00
Modify  | 0.69954    | 0.69954    | 0.69954    |   0.0 |  1.08
Other   |            | 0.1012     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697164.0 ave      697164 max      697164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697164
Ave neighs/atom = 174.29100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943800161888, Press = -1.12672321590988
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17508.285   -17508.285   -17649.414   -17649.414    273.02299    273.02299    43599.878    43599.878   -57.232784   -57.232784 
   61000    -17512.99    -17512.99   -17655.534   -17655.534    275.76263    275.76263    43578.091    43578.091    747.19509    747.19509 
Loop time of 64.8499 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.332 ns/day, 18.014 hours/ns, 15.420 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    | 63.835     | 63.835     | 63.835     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19953    | 0.19953    | 0.19953    |   0.0 |  0.31
Output  | 0.00017671 | 0.00017671 | 0.00017671 |   0.0 |  0.00
Modify  | 0.71389    | 0.71389    | 0.71389    |   0.0 |  1.10
Other   |            | 0.1012     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697014.0 ave      697014 max      697014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697014
Ave neighs/atom = 174.25350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.957115494234, Press = -1.05033613643077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000    -17512.99    -17512.99   -17655.534   -17655.534    275.76263    275.76263    43578.091    43578.091    747.19509    747.19509 
   62000   -17512.041   -17512.041   -17652.136   -17652.136    271.02225    271.02225    43580.029    43580.029    717.83526    717.83526 
Loop time of 64.4896 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.914 hours/ns, 15.506 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    | 63.488     | 63.488     | 63.488     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1984     | 0.1984     | 0.1984     |   0.0 |  0.31
Output  | 0.00017595 | 0.00017595 | 0.00017595 |   0.0 |  0.00
Modify  | 0.7015     | 0.7015     | 0.7015     |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697660.0 ave      697660 max      697660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697660
Ave neighs/atom = 174.41500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.987173026037, Press = -0.99298637570233
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17512.041   -17512.041   -17652.136   -17652.136    271.02225    271.02225    43580.029    43580.029    717.83526    717.83526 
   63000   -17510.933   -17510.933   -17651.078   -17651.078    271.12061    271.12061    43568.435    43568.435    937.44957    937.44957 
Loop time of 64.3215 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.343 ns/day, 17.867 hours/ns, 15.547 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    | 63.318     | 63.318     | 63.318     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19978    | 0.19978    | 0.19978    |   0.0 |  0.31
Output  | 0.00022898 | 0.00022898 | 0.00022898 |   0.0 |  0.00
Modify  | 0.70198    | 0.70198    | 0.70198    |   0.0 |  1.09
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697042.0 ave      697042 max      697042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697042
Ave neighs/atom = 174.26050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.968433655942, Press = -0.938483889516414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17510.933   -17510.933   -17651.078   -17651.078    271.12061    271.12061    43568.435    43568.435    937.44957    937.44957 
   64000   -17517.853   -17517.853   -17657.631   -17657.631    270.40904    270.40904    43554.687    43554.687    1625.6948    1625.6948 
Loop time of 64.3714 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.881 hours/ns, 15.535 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    | 63.375     | 63.375     | 63.375     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19815    | 0.19815    | 0.19815    |   0.0 |  0.31
Output  | 0.0002277  | 0.0002277  | 0.0002277  |   0.0 |  0.00
Modify  | 0.69703    | 0.69703    | 0.69703    |   0.0 |  1.08
Other   |            | 0.1007     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697236.0 ave      697236 max      697236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697236
Ave neighs/atom = 174.30900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.95078711067, Press = -1.19512504590584
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17517.853   -17517.853   -17657.631   -17657.631    270.40904    270.40904    43554.687    43554.687    1625.6948    1625.6948 
   65000   -17511.758   -17511.758   -17652.408   -17652.408    272.09695    272.09695    43557.938    43557.938    1522.7826    1522.7826 
Loop time of 65.1299 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.327 ns/day, 18.092 hours/ns, 15.354 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    | 64.112     | 64.112     | 64.112     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20052    | 0.20052    | 0.20052    |   0.0 |  0.31
Output  | 0.0002276  | 0.0002276  | 0.0002276  |   0.0 |  0.00
Modify  | 0.71478    | 0.71478    | 0.71478    |   0.0 |  1.10
Other   |            | 0.1021     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697994.0 ave      697994 max      697994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697994
Ave neighs/atom = 174.49850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.941217495285, Press = -1.01021625728667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17511.758   -17511.758   -17652.408   -17652.408    272.09695    272.09695    43557.938    43557.938    1522.7826    1522.7826 
   66000   -17507.988   -17507.988   -17648.902   -17648.902    272.60789    272.60789    43581.731    43581.731    541.98423    541.98423 
Loop time of 65.4956 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.193 hours/ns, 15.268 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    | 64.47      | 64.47      | 64.47      |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20246    | 0.20246    | 0.20246    |   0.0 |  0.31
Output  | 0.00022958 | 0.00022958 | 0.00022958 |   0.0 |  0.00
Modify  | 0.72055    | 0.72055    | 0.72055    |   0.0 |  1.10
Other   |            | 0.1026     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697398.0 ave      697398 max      697398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697398
Ave neighs/atom = 174.34950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.944075196157, Press = -0.787392367469242
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -17507.988   -17507.988   -17648.902   -17648.902    272.60789    272.60789    43581.731    43581.731    541.98423    541.98423 
   67000   -17512.898   -17512.898   -17656.725   -17656.725    278.24223    278.24223    43592.846    43592.846    231.34332    231.34332 
Loop time of 64.1562 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.347 ns/day, 17.821 hours/ns, 15.587 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    | 63.16      | 63.16      | 63.16      |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19759    | 0.19759    | 0.19759    |   0.0 |  0.31
Output  | 0.00037456 | 0.00037456 | 0.00037456 |   0.0 |  0.00
Modify  | 0.69716    | 0.69716    | 0.69716    |   0.0 |  1.09
Other   |            | 0.1008     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696970.0 ave      696970 max      696970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696970
Ave neighs/atom = 174.24250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.975301180969, Press = -0.575813358813133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -17512.898   -17512.898   -17656.725   -17656.725    278.24223    278.24223    43592.846    43592.846    231.34332    231.34332 
   68000   -17509.149   -17509.149   -17649.657   -17649.657    271.82269    271.82269    43603.839    43603.839   -262.67507   -262.67507 
Loop time of 64.1905 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.346 ns/day, 17.831 hours/ns, 15.579 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    | 63.184     | 63.184     | 63.184     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19926    | 0.19926    | 0.19926    |   0.0 |  0.31
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.70484    | 0.70484    | 0.70484    |   0.0 |  1.10
Other   |            | 0.1019     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697176.0 ave      697176 max      697176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697176
Ave neighs/atom = 174.29400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.978754633066, Press = -0.512981142363293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -17509.149   -17509.149   -17649.657   -17649.657    271.82269    271.82269    43603.839    43603.839   -262.67507   -262.67507 
   69000   -17512.878   -17512.878   -17654.812   -17654.812    274.58164    274.58164    43608.187    43608.187   -475.39312   -475.39312 
Loop time of 64.9574 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.330 ns/day, 18.044 hours/ns, 15.395 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    | 63.947     | 63.947     | 63.947     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20039    | 0.20039    | 0.20039    |   0.0 |  0.31
Output  | 0.00017564 | 0.00017564 | 0.00017564 |   0.0 |  0.00
Modify  | 0.70778    | 0.70778    | 0.70778    |   0.0 |  1.09
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696846.0 ave      696846 max      696846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696846
Ave neighs/atom = 174.21150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.015151738966, Press = -0.786208523865747
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -17512.878   -17512.878   -17654.812   -17654.812    274.58164    274.58164    43608.187    43608.187   -475.39312   -475.39312 
   70000   -17508.566   -17508.566   -17650.666   -17650.666    274.90324    274.90324     43615.54     43615.54   -725.14748   -725.14748 
Loop time of 64.7351 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.335 ns/day, 17.982 hours/ns, 15.448 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    | 63.722     | 63.722     | 63.722     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20038    | 0.20038    | 0.20038    |   0.0 |  0.31
Output  | 0.00017506 | 0.00017506 | 0.00017506 |   0.0 |  0.00
Modify  | 0.7107     | 0.7107     | 0.7107     |   0.0 |  1.10
Other   |            | 0.1019     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697024.0 ave      697024 max      697024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697024
Ave neighs/atom = 174.25600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.026577499201, Press = -1.29689177085021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -17508.566   -17508.566   -17650.666   -17650.666    274.90324    274.90324     43615.54     43615.54   -725.14748   -725.14748 
   71000   -17512.846   -17512.846   -17652.731   -17652.731    270.61679    270.61679    43597.251    43597.251    -3.292093    -3.292093 
Loop time of 63.5323 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.648 hours/ns, 15.740 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    | 62.54      | 62.54      | 62.54      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19787    | 0.19787    | 0.19787    |   0.0 |  0.31
Output  | 0.00017498 | 0.00017498 | 0.00017498 |   0.0 |  0.00
Modify  | 0.69288    | 0.69288    | 0.69288    |   0.0 |  1.09
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      696900.0 ave      696900 max      696900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696900
Ave neighs/atom = 174.22500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.054098483559, Press = -1.40061581956085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -17512.846   -17512.846   -17652.731   -17652.731    270.61679    270.61679    43597.251    43597.251    -3.292093    -3.292093 
   72000   -17507.614   -17507.614   -17650.081   -17650.081    275.61173    275.61173    43585.212    43585.212    441.87881    441.87881 
Loop time of 63.7806 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.355 ns/day, 17.717 hours/ns, 15.679 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    | 62.788     | 62.788     | 62.788     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19819    | 0.19819    | 0.19819    |   0.0 |  0.31
Output  | 0.00017617 | 0.00017617 | 0.00017617 |   0.0 |  0.00
Modify  | 0.69333    | 0.69333    | 0.69333    |   0.0 |  1.09
Other   |            | 0.1009     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697346.0 ave      697346 max      697346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697346
Ave neighs/atom = 174.33650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.073612579477, Press = -0.980293595605434
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -17507.614   -17507.614   -17650.081   -17650.081    275.61173    275.61173    43585.212    43585.212    441.87881    441.87881 
   73000   -17512.668   -17512.668    -17656.38    -17656.38    278.01951    278.01951    43591.168    43591.168    208.68134    208.68134 
Loop time of 63.9984 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.777 hours/ns, 15.625 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    | 62.997     | 62.997     | 62.997     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19864    | 0.19864    | 0.19864    |   0.0 |  0.31
Output  | 0.00022684 | 0.00022684 | 0.00022684 |   0.0 |  0.00
Modify  | 0.70142    | 0.70142    | 0.70142    |   0.0 |  1.10
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697214.0 ave      697214 max      697214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697214
Ave neighs/atom = 174.30350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.088788477311, Press = -0.83044194814517
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -17512.668   -17512.668    -17656.38    -17656.38    278.01951    278.01951    43591.168    43591.168    208.68134    208.68134 
   74000   -17512.105   -17512.105   -17655.514   -17655.514    277.43605    277.43605    43587.658    43587.658    394.58465    394.58465 
Loop time of 63.9207 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.352 ns/day, 17.756 hours/ns, 15.644 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    | 62.925     | 62.925     | 62.925     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19848    | 0.19848    | 0.19848    |   0.0 |  0.31
Output  | 0.00017157 | 0.00017157 | 0.00017157 |   0.0 |  0.00
Modify  | 0.69506    | 0.69506    | 0.69506    |   0.0 |  1.09
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697300.0 ave      697300 max      697300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697300
Ave neighs/atom = 174.32500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.091350701346, Press = -0.728326968722282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -17512.105   -17512.105   -17655.514   -17655.514    277.43605    277.43605    43587.658    43587.658    394.58465    394.58465 
   75000   -17514.601   -17514.601   -17652.367   -17652.367    266.51679    266.51679    43575.702    43575.702    653.26089    653.26089 
Loop time of 64.5734 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.338 ns/day, 17.937 hours/ns, 15.486 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    | 63.563     | 63.563     | 63.563     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20007    | 0.20007    | 0.20007    |   0.0 |  0.31
Output  | 0.00023045 | 0.00023045 | 0.00023045 |   0.0 |  0.00
Modify  | 0.70852    | 0.70852    | 0.70852    |   0.0 |  1.10
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697442.0 ave      697442 max      697442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697442
Ave neighs/atom = 174.36050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.087855994217, Press = -0.683859605437369
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -17514.601   -17514.601   -17652.367   -17652.367    266.51679    266.51679    43575.702    43575.702    653.26089    653.26089 
   76000   -17515.548   -17515.548   -17655.644   -17655.644    271.02472    271.02472    43521.087    43521.087    2770.7487    2770.7487 
Loop time of 63.4846 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.635 hours/ns, 15.752 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    | 62.496     | 62.496     | 62.496     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19799    | 0.19799    | 0.19799    |   0.0 |  0.31
Output  | 0.00017915 | 0.00017915 | 0.00017915 |   0.0 |  0.00
Modify  | 0.69025    | 0.69025    | 0.69025    |   0.0 |  1.09
Other   |            | 0.1005     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697144.0 ave      697144 max      697144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697144
Ave neighs/atom = 174.28600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.092510260223, Press = -1.08292822411772
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -17515.548   -17515.548   -17655.644   -17655.644    271.02472    271.02472    43521.087    43521.087    2770.7487    2770.7487 
   77000   -17511.558   -17511.558    -17654.05    -17654.05    275.66118    275.66118    43541.033    43541.033     2124.432     2124.432 
Loop time of 63.7804 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.355 ns/day, 17.717 hours/ns, 15.679 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    | 62.787     | 62.787     | 62.787     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19695    | 0.19695    | 0.19695    |   0.0 |  0.31
Output  | 0.00022273 | 0.00022273 | 0.00022273 |   0.0 |  0.00
Modify  | 0.69412    | 0.69412    | 0.69412    |   0.0 |  1.09
Other   |            | 0.1017     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      698144.0 ave      698144 max      698144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 698144
Ave neighs/atom = 174.53600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.087280576599, Press = -0.589456550806959
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -17511.558   -17511.558    -17654.05    -17654.05    275.66118    275.66118    43541.033    43541.033     2124.432     2124.432 
   78000   -17515.042   -17515.042   -17653.257   -17653.257    267.38603    267.38603    43559.646    43559.646    1286.4183    1286.4183 
Loop time of 64.4289 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.341 ns/day, 17.897 hours/ns, 15.521 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    | 63.423     | 63.423     | 63.423     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19912    | 0.19912    | 0.19912    |   0.0 |  0.31
Output  | 0.00017873 | 0.00017873 | 0.00017873 |   0.0 |  0.00
Modify  | 0.70392    | 0.70392    | 0.70392    |   0.0 |  1.09
Other   |            | 0.1027     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697642.0 ave      697642 max      697642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697642
Ave neighs/atom = 174.41050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.086573489618, Press = -0.354769034015348
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 6.244 | 6.244 | 6.244 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -17515.042   -17515.042   -17653.257   -17653.257    267.38603    267.38603    43559.646    43559.646    1286.4183    1286.4183 
   79000   -17509.829   -17509.829    -17651.22    -17651.22    273.53111    273.53111     43568.72     43568.72     1147.619     1147.619 
Loop time of 64.1926 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.346 ns/day, 17.831 hours/ns, 15.578 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    | 63.199     | 63.199     | 63.199     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19872    | 0.19872    | 0.19872    |   0.0 |  0.31
Output  | 0.00022659 | 0.00022659 | 0.00022659 |   0.0 |  0.00
Modify  | 0.69453    | 0.69453    | 0.69453    |   0.0 |  1.08
Other   |            | 0.1004     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      697490.0 ave      697490 max      697490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697490
Ave neighs/atom = 174.37250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
43595.5817140618

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0