# 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.006 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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   -17647.436   -17647.436   -17798.969   -17798.969       293.15       293.15    43587.987    43587.987    3713.3068    3713.3068 
    1000   -17481.752   -17481.752   -17634.746   -17634.746    295.97812    295.97812    43590.538    43590.538    599.40448    599.40448 
Loop time of 64.3687 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.880 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.365     | 63.365     | 63.365     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20378    | 0.20378    | 0.20378    |   0.0 |  0.32
Output  | 0.00032332 | 0.00032332 | 0.00032332 |   0.0 |  0.00
Modify  | 0.69687    | 0.69687    | 0.69687    |   0.0 |  1.08
Other   |            | 0.1031     |            |       |  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   -17481.752   -17481.752   -17634.746   -17634.746    295.97812    295.97812    43590.538    43590.538    599.40448    599.40448 
    2000   -17493.524   -17493.524   -17642.137   -17642.137    287.50256    287.50256    43568.929    43568.929    1175.2917    1175.2917 
Loop time of 63.8367 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.732 hours/ns, 15.665 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.868     | 62.868     | 62.868     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.197      | 0.197      | 0.197      |   0.0 |  0.31
Output  | 0.00021383 | 0.00021383 | 0.00021383 |   0.0 |  0.00
Modify  | 0.66919    | 0.66919    | 0.66919    |   0.0 |  1.05
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:      696152.0 ave      696152 max      696152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696152
Ave neighs/atom = 174.03800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -17493.524   -17493.524   -17642.137   -17642.137    287.50256    287.50256    43568.929    43568.929    1175.2917    1175.2917 
    3000    -17491.23    -17491.23   -17642.448   -17642.448    292.54077    292.54077    43590.037    43590.037    485.10198    485.10198 
Loop time of 65.0393 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.328 ns/day, 18.066 hours/ns, 15.375 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.058     | 64.058     | 64.058     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20032    | 0.20032    | 0.20032    |   0.0 |  0.31
Output  | 0.00020732 | 0.00020732 | 0.00020732 |   0.0 |  0.00
Modify  | 0.67944    | 0.67944    | 0.67944    |   0.0 |  1.04
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:      696462.0 ave      696462 max      696462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696462
Ave neighs/atom = 174.11550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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    -17491.23    -17491.23   -17642.448   -17642.448    292.54077    292.54077    43590.037    43590.037    485.10198    485.10198 
    4000    -17490.09    -17490.09   -17644.666   -17644.666    299.03687    299.03687    43602.559    43602.559   -171.40055   -171.40055 
Loop time of 65.3987 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.166 hours/ns, 15.291 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.403     | 64.403     | 64.403     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2023     | 0.2023     | 0.2023     |   0.0 |  0.31
Output  | 0.00022615 | 0.00022615 | 0.00022615 |   0.0 |  0.00
Modify  | 0.69031    | 0.69031    | 0.69031    |   0.0 |  1.06
Other   |            | 0.1029     |            |       |  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:      696230.0 ave      696230 max      696230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696230
Ave neighs/atom = 174.05750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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    -17490.09    -17490.09   -17644.666   -17644.666    299.03687    299.03687    43602.559    43602.559   -171.40055   -171.40055 
    5000   -17492.758   -17492.758   -17637.409   -17637.409    279.83634    279.83634    43644.895    43644.895    -1843.473    -1843.473 
Loop time of 64.4438 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.341 ns/day, 17.901 hours/ns, 15.517 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.463     | 63.463     | 63.463     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19942    | 0.19942    | 0.19942    |   0.0 |  0.31
Output  | 0.00017688 | 0.00017688 | 0.00017688 |   0.0 |  0.00
Modify  | 0.67821    | 0.67821    | 0.67821    |   0.0 |  1.05
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:      695566.0 ave      695566 max      695566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695566
Ave neighs/atom = 173.89150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818603050567, Press = -401.123778952466
next a
jump SELF top
variable a loop 2000
run 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   -17492.758   -17492.758   -17637.409   -17637.409    279.83634    279.83634    43644.895    43644.895    -1843.473    -1843.473 
    6000   -17488.256   -17488.256    -17642.89    -17642.89    299.15118    299.15118    43652.894    43652.894   -1886.9901   -1886.9901 
Loop time of 64.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.887 hours/ns, 15.530 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.39      | 63.39      | 63.39      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19904    | 0.19904    | 0.19904    |   0.0 |  0.31
Output  | 0.00017692 | 0.00017692 | 0.00017692 |   0.0 |  0.00
Modify  | 0.7011     | 0.7011     | 0.7011     |   0.0 |  1.09
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:      695422.0 ave      695422 max      695422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695422
Ave neighs/atom = 173.85550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.848135186945, Press = 37.3631865407487
next a
jump SELF top
variable a loop 2000
run 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   -17488.256   -17488.256    -17642.89    -17642.89    299.15118    299.15118    43652.894    43652.894   -1886.9901   -1886.9901 
    7000   -17492.824   -17492.824   -17651.427   -17651.427    306.82891    306.82891    43594.015    43594.015    576.47463    576.47463 
Loop time of 65.3963 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.166 hours/ns, 15.291 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.382     | 64.382     | 64.382     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20145    | 0.20145    | 0.20145    |   0.0 |  0.31
Output  | 0.00018306 | 0.00018306 | 0.00018306 |   0.0 |  0.00
Modify  | 0.70955    | 0.70955    | 0.70955    |   0.0 |  1.09
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:      695392.0 ave      695392 max      695392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695392
Ave neighs/atom = 173.84800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992525198536, Press = 15.2157354392364
next a
jump SELF top
variable a loop 2000
run 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   -17492.824   -17492.824   -17651.427   -17651.427    306.82891    306.82891    43594.015    43594.015    576.47463    576.47463 
    8000   -17491.087   -17491.087   -17644.475   -17644.475    296.73914    296.73914    43584.466    43584.466    741.31364    741.31364 
Loop time of 65.0243 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.329 ns/day, 18.062 hours/ns, 15.379 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.015     | 64.015     | 64.015     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19963    | 0.19963    | 0.19963    |   0.0 |  0.31
Output  | 0.00017078 | 0.00017078 | 0.00017078 |   0.0 |  0.00
Modify  | 0.70661    | 0.70661    | 0.70661    |   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:      697654.0 ave      697654 max      697654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697654
Ave neighs/atom = 174.41350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824627771958, Press = -1.93397326355932
next a
jump SELF top
variable a loop 2000
run 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   -17491.087   -17491.087   -17644.475   -17644.475    296.73914    296.73914    43584.466    43584.466    741.31364    741.31364 
    9000   -17489.275   -17489.275   -17641.515   -17641.515    294.51804    294.51804     43583.37     43583.37    657.50719    657.50719 
Loop time of 65.9728 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.326 hours/ns, 15.158 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.947     | 64.947     | 64.947     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20289    | 0.20289    | 0.20289    |   0.0 |  0.31
Output  | 0.00023374 | 0.00023374 | 0.00023374 |   0.0 |  0.00
Modify  | 0.71939    | 0.71939    | 0.71939    |   0.0 |  1.09
Other   |            | 0.1033     |            |       |  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:      696388.0 ave      696388 max      696388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696388
Ave neighs/atom = 174.09700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82558146188, Press = -2.912813924317
next a
jump SELF top
variable a loop 2000
run 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   -17489.275   -17489.275   -17641.515   -17641.515    294.51804    294.51804     43583.37     43583.37    657.50719    657.50719 
   10000   -17489.435   -17489.435   -17644.436   -17644.436    299.86088    299.86088    43585.106    43585.106    739.55593    739.55593 
Loop time of 66.1007 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.307 ns/day, 18.361 hours/ns, 15.128 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.078     | 65.078     | 65.078     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20257    | 0.20257    | 0.20257    |   0.0 |  0.31
Output  | 0.0001718  | 0.0001718  | 0.0001718  |   0.0 |  0.00
Modify  | 0.71807    | 0.71807    | 0.71807    |   0.0 |  1.09
Other   |            | 0.1017     |            |       |  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:      696728.0 ave      696728 max      696728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696728
Ave neighs/atom = 174.18200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.70302751968, Press = -5.75647343761548
next a
jump SELF top
variable a loop 2000
run 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   -17489.435   -17489.435   -17644.436   -17644.436    299.86088    299.86088    43585.106    43585.106    739.55593    739.55593 
   11000   -17499.702   -17499.702   -17645.403   -17645.403    281.86826    281.86826    43613.317    43613.317   -447.78866   -447.78866 
Loop time of 64.4451 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.341 ns/day, 17.901 hours/ns, 15.517 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.449     | 63.449     | 63.449     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19858    | 0.19858    | 0.19858    |   0.0 |  0.31
Output  | 0.00017905 | 0.00017905 | 0.00017905 |   0.0 |  0.00
Modify  | 0.69467    | 0.69467    | 0.69467    |   0.0 |  1.08
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:      696594.0 ave      696594 max      696594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696594
Ave neighs/atom = 174.14850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.639913715853, Press = -9.56287100491423
next a
jump SELF top
variable a loop 2000
run 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   -17499.702   -17499.702   -17645.403   -17645.403    281.86826    281.86826    43613.317    43613.317   -447.78866   -447.78866 
   12000    -17489.37    -17489.37   -17644.273   -17644.273    299.66953    299.66953    43658.009    43658.009   -2097.8611   -2097.8611 
Loop time of 65.6457 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.235 hours/ns, 15.233 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.615     | 64.615     | 64.615     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20351    | 0.20351    | 0.20351    |   0.0 |  0.31
Output  | 0.00022352 | 0.00022352 | 0.00022352 |   0.0 |  0.00
Modify  | 0.72344    | 0.72344    | 0.72344    |   0.0 |  1.10
Other   |            | 0.1033     |            |       |  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:      696160.0 ave      696160 max      696160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696160
Ave neighs/atom = 174.04000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.474331689846, Press = -3.30332058050557
next a
jump SELF top
variable a loop 2000
run 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    -17489.37    -17489.37   -17644.273   -17644.273    299.66953    299.66953    43658.009    43658.009   -2097.8611   -2097.8611 
   13000   -17495.243   -17495.243   -17645.349   -17645.349    290.39094    290.39094    43636.307    43636.307   -1304.0685   -1304.0685 
Loop time of 66.7516 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.294 ns/day, 18.542 hours/ns, 14.981 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.712     | 65.712     | 65.712     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20524    | 0.20524    | 0.20524    |   0.0 |  0.31
Output  | 0.00017426 | 0.00017426 | 0.00017426 |   0.0 |  0.00
Modify  | 0.72972    | 0.72972    | 0.72972    |   0.0 |  1.09
Other   |            | 0.104      |            |       |  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:      695618.0 ave      695618 max      695618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695618
Ave neighs/atom = 173.90450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.425216021678, Press = 2.12443379820983
next a
jump SELF top
variable a loop 2000
run 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   -17495.243   -17495.243   -17645.349   -17645.349    290.39094    290.39094    43636.307    43636.307   -1304.0685   -1304.0685 
   14000   -17491.216   -17491.216   -17643.329   -17643.329    294.27205    294.27205    43592.197    43592.197    404.76958    404.76958 
Loop time of 65.0179 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.329 ns/day, 18.061 hours/ns, 15.380 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.006     | 64.006     | 64.006     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20093    | 0.20093    | 0.20093    |   0.0 |  0.31
Output  | 0.0002278  | 0.0002278  | 0.0002278  |   0.0 |  0.00
Modify  | 0.70839    | 0.70839    | 0.70839    |   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:      695860.0 ave      695860 max      695860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695860
Ave neighs/atom = 173.96500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.440613363677, Press = 2.94347018970467
next a
jump SELF top
variable a loop 2000
run 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   -17491.216   -17491.216   -17643.329   -17643.329    294.27205    294.27205    43592.197    43592.197    404.76958    404.76958 
   15000   -17487.444   -17487.444   -17637.289   -17637.289    289.88467    289.88467     43597.53     43597.53    64.069246    64.069246 
Loop time of 65.4343 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.320 ns/day, 18.176 hours/ns, 15.283 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.408     | 64.408     | 64.408     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2018     | 0.2018     | 0.2018     |   0.0 |  0.31
Output  | 0.00037766 | 0.00037766 | 0.00037766 |   0.0 |  0.00
Modify  | 0.71977    | 0.71977    | 0.71977    |   0.0 |  1.10
Other   |            | 0.1038     |            |       |  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:      696740.0 ave      696740 max      696740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696740
Ave neighs/atom = 174.18500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.469828492791, Press = -1.1835739190776
next a
jump SELF top
variable a loop 2000
run 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   -17487.444   -17487.444   -17637.289   -17637.289    289.88467    289.88467     43597.53     43597.53    64.069246    64.069246 
   16000   -17491.716   -17491.716   -17646.902   -17646.902     300.2196     300.2196    43598.441    43598.441     285.8384     285.8384 
Loop time of 66.2521 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.304 ns/day, 18.403 hours/ns, 15.094 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.214     | 65.214     | 65.214     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20338    | 0.20338    | 0.20338    |   0.0 |  0.31
Output  | 0.00017793 | 0.00017793 | 0.00017793 |   0.0 |  0.00
Modify  | 0.73088    | 0.73088    | 0.73088    |   0.0 |  1.10
Other   |            | 0.1037     |            |       |  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:      695744.0 ave      695744 max      695744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695744
Ave neighs/atom = 173.93600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.634996749974, Press = -1.70444013239054
next a
jump SELF top
variable a loop 2000
run 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   -17491.716   -17491.716   -17646.902   -17646.902     300.2196     300.2196    43598.441    43598.441     285.8384     285.8384 
   17000   -17489.105   -17489.105   -17641.908   -17641.908    295.60656    295.60656     43612.08     43612.08   -240.07441   -240.07441 
Loop time of 65.1876 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.325 ns/day, 18.108 hours/ns, 15.340 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.171     | 64.171     | 64.171     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20205    | 0.20205    | 0.20205    |   0.0 |  0.31
Output  | 0.00017876 | 0.00017876 | 0.00017876 |   0.0 |  0.00
Modify  | 0.71172    | 0.71172    | 0.71172    |   0.0 |  1.09
Other   |            | 0.103      |            |       |  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:      697294.0 ave      697294 max      697294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 697294
Ave neighs/atom = 174.32350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784573932571, Press = -1.69889291236411
next a
jump SELF top
variable a loop 2000
run 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   -17489.105   -17489.105   -17641.908   -17641.908    295.60656    295.60656     43612.08     43612.08   -240.07441   -240.07441 
   18000   -17488.851   -17488.851   -17640.073   -17640.073    292.54925    292.54925    43636.879    43636.879   -1414.7481   -1414.7481 
Loop time of 65.1835 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.325 ns/day, 18.107 hours/ns, 15.341 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.167     | 64.167     | 64.167     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20144    | 0.20144    | 0.20144    |   0.0 |  0.31
Output  | 0.00017533 | 0.00017533 | 0.00017533 |   0.0 |  0.00
Modify  | 0.71287    | 0.71287    | 0.71287    |   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:      696542.0 ave      696542 max      696542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696542
Ave neighs/atom = 174.13550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.732384132877, Press = -1.16206248600725
next a
jump SELF top
variable a loop 2000
run 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   -17488.851   -17488.851   -17640.073   -17640.073    292.54925    292.54925    43636.879    43636.879   -1414.7481   -1414.7481 
   19000    -17490.69    -17490.69   -17642.107   -17642.107    292.92625    292.92625    43600.074    43600.074   -2.6380581   -2.6380581 
Loop time of 66.2454 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.304 ns/day, 18.402 hours/ns, 15.095 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.209     | 65.209     | 65.209     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2041     | 0.2041     | 0.2041     |   0.0 |  0.31
Output  | 0.00017108 | 0.00017108 | 0.00017108 |   0.0 |  0.00
Modify  | 0.72939    | 0.72939    | 0.72939    |   0.0 |  1.10
Other   |            | 0.1024     |            |       |  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:      695968.0 ave      695968 max      695968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695968
Ave neighs/atom = 173.99200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.70038904605, Press = 2.74710357682291
next a
jump SELF top
variable a loop 2000
run 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    -17490.69    -17490.69   -17642.107   -17642.107    292.92625    292.92625    43600.074    43600.074   -2.6380581   -2.6380581 
   20000   -17491.988   -17491.988   -17643.646   -17643.646     293.3924     293.3924    43559.101    43559.101    1683.9681    1683.9681 
Loop time of 64.6833 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.336 ns/day, 17.968 hours/ns, 15.460 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.678     | 63.678     | 63.678     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19925    | 0.19925    | 0.19925    |   0.0 |  0.31
Output  | 0.00017674 | 0.00017674 | 0.00017674 |   0.0 |  0.00
Modify  | 0.70257    | 0.70257    | 0.70257    |   0.0 |  1.09
Other   |            | 0.1032     |            |       |  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:      696316.0 ave      696316 max      696316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696316
Ave neighs/atom = 174.07900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.61211715613, Press = 0.773028164061696
next a
jump SELF top
variable a loop 2000
run 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   -17491.988   -17491.988   -17643.646   -17643.646     293.3924     293.3924    43559.101    43559.101    1683.9681    1683.9681 
   21000   -17488.575   -17488.575   -17641.039   -17641.039    294.95108    294.95108    43555.987    43555.987    1702.3764    1702.3764 
Loop time of 66.1321 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.108     | 65.108     | 65.108     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20199    | 0.20199    | 0.20199    |   0.0 |  0.31
Output  | 0.00017813 | 0.00017813 | 0.00017813 |   0.0 |  0.00
Modify  | 0.71947    | 0.71947    | 0.71947    |   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:      696904.0 ave      696904 max      696904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696904
Ave neighs/atom = 174.22600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.573031024993, Press = -2.44592907128065
next a
jump SELF top
variable a loop 2000
run 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   -17488.575   -17488.575   -17641.039   -17641.039    294.95108    294.95108    43555.987    43555.987    1702.3764    1702.3764 
   22000   -17494.285   -17494.285   -17644.684   -17644.684    290.95768    290.95768    43606.597    43606.597   -169.46742   -169.46742 
Loop time of 65.7957 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.277 hours/ns, 15.199 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.768     | 64.768     | 64.768     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20439    | 0.20439    | 0.20439    |   0.0 |  0.31
Output  | 0.00017393 | 0.00017393 | 0.00017393 |   0.0 |  0.00
Modify  | 0.72061    | 0.72061    | 0.72061    |   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:      696802.0 ave      696802 max      696802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696802
Ave neighs/atom = 174.20050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.561962456338, Press = -2.97444357321205
next a
jump SELF top
variable a loop 2000
run 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   -17494.285   -17494.285   -17644.684   -17644.684    290.95768    290.95768    43606.597    43606.597   -169.46742   -169.46742 
   23000   -17493.407   -17493.407   -17645.318   -17645.318    293.88184    293.88184    43621.088    43621.088   -724.02132   -724.02132 
Loop time of 65.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.320 ns/day, 18.181 hours/ns, 15.278 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 64.426     | 64.426     | 64.426     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20151    | 0.20151    | 0.20151    |   0.0 |  0.31
Output  | 0.00017619 | 0.00017619 | 0.00017619 |   0.0 |  0.00
Modify  | 0.72038    | 0.72038    | 0.72038    |   0.0 |  1.10
Other   |            | 0.1036     |            |       |  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:      696198.0 ave      696198 max      696198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696198
Ave neighs/atom = 174.04950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.595657860803, Press = -1.13621872043747
next a
jump SELF top
variable a loop 2000
run 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   -17493.407   -17493.407   -17645.318   -17645.318    293.88184    293.88184    43621.088    43621.088   -724.02132   -724.02132 
   24000   -17488.275   -17488.275   -17638.337   -17638.337    290.30585    290.30585    43614.908    43614.908   -562.23047   -562.23047 
Loop time of 65.1079 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.327 ns/day, 18.086 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.1       | 64.1       | 64.1       |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19915    | 0.19915    | 0.19915    |   0.0 |  0.31
Output  | 0.00017683 | 0.00017683 | 0.00017683 |   0.0 |  0.00
Modify  | 0.70557    | 0.70557    | 0.70557    |   0.0 |  1.08
Other   |            | 0.1031     |            |       |  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:      696230.0 ave      696230 max      696230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696230
Ave neighs/atom = 174.05750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.688759220046, Press = -0.188259507334147
next a
jump SELF top
variable a loop 2000
run 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   -17488.275   -17488.275   -17638.337   -17638.337    290.30585    290.30585    43614.908    43614.908   -562.23047   -562.23047 
   25000   -17492.946   -17492.946   -17642.835   -17642.835    289.96951    289.96951    43602.512    43602.512   -97.327954   -97.327954 
Loop time of 65.9185 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.311 hours/ns, 15.170 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.892     | 64.892     | 64.892     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20199    | 0.20199    | 0.20199    |   0.0 |  0.31
Output  | 0.00017759 | 0.00017759 | 0.00017759 |   0.0 |  0.00
Modify  | 0.72151    | 0.72151    | 0.72151    |   0.0 |  1.09
Other   |            | 0.1029     |            |       |  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:      695452.0 ave      695452 max      695452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695452
Ave neighs/atom = 173.86300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72716508682, Press = -0.726047366510241
next a
jump SELF top
variable a loop 2000
run 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   -17492.946   -17492.946   -17642.835   -17642.835    289.96951    289.96951    43602.512    43602.512   -97.327954   -97.327954 
   26000   -17489.837   -17489.837   -17642.573   -17642.573    295.47862    295.47862    43593.346    43593.346    226.98147    226.98147 
Loop time of 64.7315 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.335 ns/day, 17.981 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.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20023    | 0.20023    | 0.20023    |   0.0 |  0.31
Output  | 0.00017426 | 0.00017426 | 0.00017426 |   0.0 |  0.00
Modify  | 0.7064     | 0.7064     | 0.7064     |   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:      696562.0 ave      696562 max      696562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696562
Ave neighs/atom = 174.14050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.686228916685, Press = -0.715849502081416
next a
jump SELF top
variable a loop 2000
run 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   -17489.837   -17489.837   -17642.573   -17642.573    295.47862    295.47862    43593.346    43593.346    226.98147    226.98147 
   27000   -17493.079   -17493.079   -17646.265   -17646.265    296.34808    296.34808    43598.305    43598.305    145.80509    145.80509 
Loop time of 66.5485 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.298 ns/day, 18.486 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.511     | 65.511     | 65.511     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20542    | 0.20542    | 0.20542    |   0.0 |  0.31
Output  | 0.00017673 | 0.00017673 | 0.00017673 |   0.0 |  0.00
Modify  | 0.72879    | 0.72879    | 0.72879    |   0.0 |  1.10
Other   |            | 0.1032     |            |       |  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:      696302.0 ave      696302 max      696302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696302
Ave neighs/atom = 174.07550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.669320441336, Press = -1.23685422808567
next a
jump SELF top
variable a loop 2000
run 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   -17493.079   -17493.079   -17646.265   -17646.265    296.34808    296.34808    43598.305    43598.305    145.80509    145.80509 
   28000   -17494.538   -17494.538   -17641.949   -17641.949    285.17733    285.17733    43603.114    43603.114   -99.991964   -99.991964 
Loop time of 65.5146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.198 hours/ns, 15.264 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.493     | 64.493     | 64.493     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20221    | 0.20221    | 0.20221    |   0.0 |  0.31
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.71561    | 0.71561    | 0.71561    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      696758.0 ave      696758 max      696758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696758
Ave neighs/atom = 174.18950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.636009850378, Press = -1.4370268033943
next a
jump SELF top
variable a loop 2000
run 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   -17494.538   -17494.538   -17641.949   -17641.949    285.17733    285.17733    43603.114    43603.114   -99.991964   -99.991964 
   29000   -17492.512   -17492.512   -17642.829   -17642.829    290.79722    290.79722    43638.918    43638.918    -1374.764    -1374.764 
Loop time of 63.8454 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.735 hours/ns, 15.663 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.854     | 62.854     | 62.854     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19798    | 0.19798    | 0.19798    |   0.0 |  0.31
Output  | 0.00018014 | 0.00018014 | 0.00018014 |   0.0 |  0.00
Modify  | 0.69138    | 0.69138    | 0.69138    |   0.0 |  1.08
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:      696040.0 ave      696040 max      696040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696040
Ave neighs/atom = 174.01000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.679265472826, Press = -1.41475522128445
next a
jump SELF top
variable a loop 2000
run 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   -17492.512   -17492.512   -17642.829   -17642.829    290.79722    290.79722    43638.918    43638.918    -1374.764    -1374.764 
   30000   -17485.499   -17485.499   -17641.892   -17641.892    302.55104    302.55104    43617.968    43617.968   -501.38602   -501.38602 
Loop time of 65.5198 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.200 hours/ns, 15.263 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.495     | 64.495     | 64.495     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20269    | 0.20269    | 0.20269    |   0.0 |  0.31
Output  | 0.00022766 | 0.00022766 | 0.00022766 |   0.0 |  0.00
Modify  | 0.7181     | 0.7181     | 0.7181     |   0.0 |  1.10
Other   |            | 0.1034     |            |       |  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:      695810.0 ave      695810 max      695810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695810
Ave neighs/atom = 173.95250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.735612049752, Press = 0.89374473245019
next a
jump SELF top
variable a loop 2000
run 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   -17485.499   -17485.499   -17641.892   -17641.892    302.55104    302.55104    43617.968    43617.968   -501.38602   -501.38602 
   31000   -17493.932   -17493.932   -17642.472   -17642.472    287.36213    287.36213    43558.814    43558.814     1639.465     1639.465 
Loop time of 63.9728 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.351 ns/day, 17.770 hours/ns, 15.632 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.974     | 62.974     | 62.974     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19761    | 0.19761    | 0.19761    |   0.0 |  0.31
Output  | 0.00022458 | 0.00022458 | 0.00022458 |   0.0 |  0.00
Modify  | 0.69902    | 0.69902    | 0.69902    |   0.0 |  1.09
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:      696188.0 ave      696188 max      696188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696188
Ave neighs/atom = 174.04700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818617727833, Press = 0.900767791987481
next a
jump SELF top
variable a loop 2000
run 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   -17493.932   -17493.932   -17642.472   -17642.472    287.36213    287.36213    43558.814    43558.814     1639.465     1639.465 
   32000   -17493.267   -17493.267   -17643.601   -17643.601    290.83066    290.83066    43545.525    43545.525    1989.3713    1989.3713 
Loop time of 64.0077 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.780 hours/ns, 15.623 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.018     | 63.018     | 63.018     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19743    | 0.19743    | 0.19743    |   0.0 |  0.31
Output  | 0.00017883 | 0.00017883 | 0.00017883 |   0.0 |  0.00
Modify  | 0.69061    | 0.69061    | 0.69061    |   0.0 |  1.08
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:      696758.0 ave      696758 max      696758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696758
Ave neighs/atom = 174.18950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808206831905, Press = -2.06017837455525
next a
jump SELF top
variable a loop 2000
run 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   -17493.267   -17493.267   -17643.601   -17643.601    290.83066    290.83066    43545.525    43545.525    1989.3713    1989.3713 
   33000   -17489.774   -17489.774   -17643.716   -17643.716    297.81189    297.81189    43610.595    43610.595   -265.36121   -265.36121 
Loop time of 63.4258 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.618 hours/ns, 15.766 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.442     | 62.442     | 62.442     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19524    | 0.19524    | 0.19524    |   0.0 |  0.31
Output  | 0.00022486 | 0.00022486 | 0.00022486 |   0.0 |  0.00
Modify  | 0.686      | 0.686      | 0.686      |   0.0 |  1.08
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:      696946.0 ave      696946 max      696946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696946
Ave neighs/atom = 174.23650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.763299517701, Press = -2.282305354375
next a
jump SELF top
variable a loop 2000
run 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   -17489.774   -17489.774   -17643.716   -17643.716    297.81189    297.81189    43610.595    43610.595   -265.36121   -265.36121 
   34000   -17492.971   -17492.971   -17647.227   -17647.227    298.41944    298.41944    43625.079    43625.079    -816.2696    -816.2696 
Loop time of 64.3847 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.885 hours/ns, 15.532 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.379     | 63.379     | 63.379     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19941    | 0.19941    | 0.19941    |   0.0 |  0.31
Output  | 0.00017792 | 0.00017792 | 0.00017792 |   0.0 |  0.00
Modify  | 0.70356    | 0.70356    | 0.70356    |   0.0 |  1.09
Other   |            | 0.103      |            |       |  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:      695996.0 ave      695996 max      695996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695996
Ave neighs/atom = 173.99900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.806297128528, Press = -0.971504931455418
next a
jump SELF top
variable a loop 2000
run 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   -17492.971   -17492.971   -17647.227   -17647.227    298.41944    298.41944    43625.079    43625.079    -816.2696    -816.2696 
   35000   -17489.181   -17489.181   -17640.513   -17640.513    292.76079    292.76079    43610.933    43610.933   -227.27783   -227.27783 
Loop time of 64.1309 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.347 ns/day, 17.814 hours/ns, 15.593 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.134     | 63.134     | 63.134     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19727    | 0.19727    | 0.19727    |   0.0 |  0.31
Output  | 0.0001792  | 0.0001792  | 0.0001792  |   0.0 |  0.00
Modify  | 0.69719    | 0.69719    | 0.69719    |   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:      696736.0 ave      696736 max      696736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696736
Ave neighs/atom = 174.18400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808035979526, Press = -0.142975633302685
next a
jump SELF top
variable a loop 2000
run 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   -17489.181   -17489.181   -17640.513   -17640.513    292.76079    292.76079    43610.933    43610.933   -227.27783   -227.27783 
   36000   -17493.329   -17493.329   -17644.443   -17644.443    292.34131    292.34131    43589.153    43589.153    551.68164    551.68164 
Loop time of 63.5639 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.657 hours/ns, 15.732 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.58      | 62.58      | 62.58      |   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.00017735 | 0.00017735 | 0.00017735 |   0.0 |  0.00
Modify  | 0.68616    | 0.68616    | 0.68616    |   0.0 |  1.08
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:      695850.0 ave      695850 max      695850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695850
Ave neighs/atom = 173.96250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884955701822, Press = 0.16065685047216
next a
jump SELF top
variable a loop 2000
run 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   -17493.329   -17493.329   -17644.443   -17644.443    292.34131    292.34131    43589.153    43589.153    551.68164    551.68164 
   37000   -17488.973   -17488.973   -17641.967   -17641.967     295.9777     295.9777    43530.837    43530.837    2822.6227    2822.6227 
Loop time of 64.5632 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.338 ns/day, 17.934 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.56      | 63.56      | 63.56      |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19932    | 0.19932    | 0.19932    |   0.0 |  0.31
Output  | 0.00017625 | 0.00017625 | 0.00017625 |   0.0 |  0.00
Modify  | 0.70131    | 0.70131    | 0.70131    |   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:      696930.0 ave      696930 max      696930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696930
Ave neighs/atom = 174.23250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.852657092912, Press = -0.206304015212619
next a
jump SELF top
variable a loop 2000
run 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   -17488.973   -17488.973   -17641.967   -17641.967     295.9777     295.9777    43530.837    43530.837    2822.6227    2822.6227 
   38000   -17495.372   -17495.372   -17644.453   -17644.453    288.40807    288.40807    43565.939    43565.939    1363.6959    1363.6959 
Loop time of 64.2413 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.345 ns/day, 17.845 hours/ns, 15.566 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.245     | 63.245     | 63.245     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19766    | 0.19766    | 0.19766    |   0.0 |  0.31
Output  | 0.00017868 | 0.00017868 | 0.00017868 |   0.0 |  0.00
Modify  | 0.69595    | 0.69595    | 0.69595    |   0.0 |  1.08
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:      696886.0 ave      696886 max      696886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696886
Ave neighs/atom = 174.22150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831211251786, Press = -2.62681749307337
next a
jump SELF top
variable a loop 2000
run 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   -17495.372   -17495.372   -17644.453   -17644.453    288.40807    288.40807    43565.939    43565.939    1363.6959    1363.6959 
   39000   -17489.897   -17489.897   -17641.163   -17641.163    292.63456    292.63456    43638.076    43638.076    -1377.213    -1377.213 
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.198      | 0.198      | 0.198      |   0.0 |  0.31
Output  | 0.00018004 | 0.00018004 | 0.00018004 |   0.0 |  0.00
Modify  | 0.69789    | 0.69789    | 0.69789    |   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:      696628.0 ave      696628 max      696628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696628
Ave neighs/atom = 174.15700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80623674106, Press = -1.89834856844633
next a
jump SELF top
variable a loop 2000
run 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   -17489.897   -17489.897   -17641.163   -17641.163    292.63456    292.63456    43638.076    43638.076    -1377.213    -1377.213 
   40000   -17494.522   -17494.522   -17642.644   -17642.644    286.55206    286.55206    43639.414    43639.414   -1595.3061   -1595.3061 
Loop time of 64.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.343 ns/day, 17.869 hours/ns, 15.545 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.334     | 63.334     | 63.334     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19833    | 0.19833    | 0.19833    |   0.0 |  0.31
Output  | 0.00017536 | 0.00017536 | 0.00017536 |   0.0 |  0.00
Modify  | 0.69495    | 0.69495    | 0.69495    |   0.0 |  1.08
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:      696008.0 ave      696008 max      696008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696008
Ave neighs/atom = 174.00200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.77716752262, Press = -0.0527565020710236
next a
jump SELF top
variable a loop 2000
run 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   -17494.522   -17494.522   -17642.644   -17642.644    286.55206    286.55206    43639.414    43639.414   -1595.3061   -1595.3061 
   41000   -17493.244   -17493.244    -17641.32    -17641.32    286.46133    286.46133    43597.267    43597.267    213.39015    213.39015 
Loop time of 64.3029 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.344 ns/day, 17.862 hours/ns, 15.551 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.303     | 63.303     | 63.303     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19878    | 0.19878    | 0.19878    |   0.0 |  0.31
Output  | 0.00043059 | 0.00043059 | 0.00043059 |   0.0 |  0.00
Modify  | 0.69801    | 0.69801    | 0.69801    |   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:      695760.0 ave      695760 max      695760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695760
Ave neighs/atom = 173.94000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.793034603773, Press = 0.479542656144657
next a
jump SELF top
variable a loop 2000
run 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   -17493.244   -17493.244    -17641.32    -17641.32    286.46133    286.46133    43597.267    43597.267    213.39015    213.39015 
   42000   -17487.187   -17487.187   -17642.782   -17642.782    301.01009    301.01009    43572.657    43572.657    1231.7254    1231.7254 
Loop time of 63.4228 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.617 hours/ns, 15.767 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.443     | 62.443     | 62.443     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19554    | 0.19554    | 0.19554    |   0.0 |  0.31
Output  | 0.00022991 | 0.00022991 | 0.00022991 |   0.0 |  0.00
Modify  | 0.6819     | 0.6819     | 0.6819     |   0.0 |  1.08
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:      696378.0 ave      696378 max      696378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696378
Ave neighs/atom = 174.09450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.840365122275, Press = -0.248252896642305
next a
jump SELF top
variable a loop 2000
run 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   -17487.187   -17487.187   -17642.782   -17642.782    301.01009    301.01009    43572.657    43572.657    1231.7254    1231.7254 
   43000    -17490.98    -17490.98   -17642.464   -17642.464    293.05682    293.05682    43592.029    43592.029    476.77925    476.77925 
Loop time of 63.7211 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.356 ns/day, 17.700 hours/ns, 15.693 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.727     | 62.727     | 62.727     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19726    | 0.19726    | 0.19726    |   0.0 |  0.31
Output  | 0.00018766 | 0.00018766 | 0.00018766 |   0.0 |  0.00
Modify  | 0.69459    | 0.69459    | 0.69459    |   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:      696688.0 ave      696688 max      696688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696688
Ave neighs/atom = 174.17200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83333285472, Press = -0.576895801405233
next a
jump SELF top
variable a loop 2000
run 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    -17490.98    -17490.98   -17642.464   -17642.464    293.05682    293.05682    43592.029    43592.029    476.77925    476.77925 
   44000   -17487.534   -17487.534   -17640.005   -17640.005    294.96521    294.96521    43602.495    43602.495   -19.406893   -19.406893 
Loop time of 64.6051 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.946 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.599     | 63.599     | 63.599     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19944    | 0.19944    | 0.19944    |   0.0 |  0.31
Output  | 0.00018188 | 0.00018188 | 0.00018188 |   0.0 |  0.00
Modify  | 0.70345    | 0.70345    | 0.70345    |   0.0 |  1.09
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:      696518.0 ave      696518 max      696518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696518
Ave neighs/atom = 174.12950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.823531160684, Press = -0.493333887373311
next a
jump SELF top
variable a loop 2000
run 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   -17487.534   -17487.534   -17640.005   -17640.005    294.96521    294.96521    43602.495    43602.495   -19.406893   -19.406893 
   45000   -17491.416   -17491.416   -17643.328   -17643.328    293.88358    293.88358    43611.035    43611.035    -340.8409    -340.8409 
Loop time of 65.0413 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.328 ns/day, 18.067 hours/ns, 15.375 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.03      | 64.03      | 64.03      |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2003     | 0.2003     | 0.2003     |   0.0 |  0.31
Output  | 0.00018077 | 0.00018077 | 0.00018077 |   0.0 |  0.00
Modify  | 0.70683    | 0.70683    | 0.70683    |   0.0 |  1.09
Other   |            | 0.1036     |            |       |  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:      696054.0 ave      696054 max      696054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696054
Ave neighs/atom = 174.01350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.841968672809, Press = -0.569323275626054
next a
jump SELF top
variable a loop 2000
run 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   -17491.416   -17491.416   -17643.328   -17643.328    293.88358    293.88358    43611.035    43611.035    -340.8409    -340.8409 
   46000   -17491.418   -17491.418   -17643.903   -17643.903    294.99203    294.99203    43597.201    43597.201    216.81674    216.81674 
Loop time of 63.2923 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.581 hours/ns, 15.800 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.309     | 62.309     | 62.309     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19788    | 0.19788    | 0.19788    |   0.0 |  0.31
Output  | 0.00017727 | 0.00017727 | 0.00017727 |   0.0 |  0.00
Modify  | 0.68325    | 0.68325    | 0.68325    |   0.0 |  1.08
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:      696170.0 ave      696170 max      696170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696170
Ave neighs/atom = 174.04250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.895910678608, Press = -0.311248088503671
next a
jump SELF top
variable a loop 2000
run 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   -17491.418   -17491.418   -17643.903   -17643.903    294.99203    294.99203    43597.201    43597.201    216.81674    216.81674 
   47000    -17486.66    -17486.66   -17638.631   -17638.631    293.99917    293.99917    43592.617    43592.617    306.75248    306.75248 
Loop time of 63.3199 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.589 hours/ns, 15.793 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.335     | 62.335     | 62.335     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19677    | 0.19677    | 0.19677    |   0.0 |  0.31
Output  | 0.00021849 | 0.00021849 | 0.00021849 |   0.0 |  0.00
Modify  | 0.68535    | 0.68535    | 0.68535    |   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:      696446.0 ave      696446 max      696446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696446
Ave neighs/atom = 174.11150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921713833776, Press = -0.286257983801288
next a
jump SELF top
variable a loop 2000
run 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    -17486.66    -17486.66   -17638.631   -17638.631    293.99917    293.99917    43592.617    43592.617    306.75248    306.75248 
   48000   -17491.118   -17491.118   -17642.558   -17642.558    292.97198    292.97198    43584.586    43584.586    626.20785    626.20785 
Loop time of 64.2152 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.345 ns/day, 17.838 hours/ns, 15.573 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.203     | 63.203     | 63.203     |   0.0 | 98.42
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19886    | 0.19886    | 0.19886    |   0.0 |  0.31
Output  | 0.00017745 | 0.00017745 | 0.00017745 |   0.0 |  0.00
Modify  | 0.70998    | 0.70998    | 0.70998    |   0.0 |  1.11
Other   |            | 0.103      |            |       |  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:      695952.0 ave      695952 max      695952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695952
Ave neighs/atom = 173.98800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.930040955347, Press = -0.924620414548743
next a
jump SELF top
variable a loop 2000
run 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   -17491.118   -17491.118   -17642.558   -17642.558    292.97198    292.97198    43584.586    43584.586    626.20785    626.20785 
   49000   -17489.848   -17489.848   -17640.927   -17640.927    292.27272    292.27272    43635.244    43635.244   -1288.3608   -1288.3608 
Loop time of 64.0202 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.783 hours/ns, 15.620 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.016     | 63.016     | 63.016     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20029    | 0.20029    | 0.20029    |   0.0 |  0.31
Output  | 0.00022732 | 0.00022732 | 0.00022732 |   0.0 |  0.00
Modify  | 0.70107    | 0.70107    | 0.70107    |   0.0 |  1.10
Other   |            | 0.1031     |            |       |  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:      696392.0 ave      696392 max      696392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696392
Ave neighs/atom = 174.09800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925884719238, Press = -1.4596055129345
next a
jump SELF top
variable a loop 2000
run 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   -17489.848   -17489.848   -17640.927   -17640.927    292.27272    292.27272    43635.244    43635.244   -1288.3608   -1288.3608 
   50000   -17490.935   -17490.935   -17642.539   -17642.539     293.2893     293.2893    43666.916    43666.916   -2426.6974   -2426.6974 
Loop time of 63.8469 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.735 hours/ns, 15.662 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.854     | 62.854     | 62.854     |   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.00018202 | 0.00018202 | 0.00018202 |   0.0 |  0.00
Modify  | 0.69291    | 0.69291    | 0.69291    |   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:      695670.0 ave      695670 max      695670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695670
Ave neighs/atom = 173.91750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896154401643, Press = -0.0676657458859273
next a
jump SELF top
variable a loop 2000
run 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   -17490.935   -17490.935   -17642.539   -17642.539     293.2893     293.2893    43666.916    43666.916   -2426.6974   -2426.6974 
   51000    -17491.63    -17491.63   -17641.873   -17641.873    290.65596    290.65596    43596.715    43596.715    135.57533    135.57533 
Loop time of 64.3955 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.342 ns/day, 17.888 hours/ns, 15.529 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.387     | 63.387     | 63.387     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19953    | 0.19953    | 0.19953    |   0.0 |  0.31
Output  | 0.0002284  | 0.0002284  | 0.0002284  |   0.0 |  0.00
Modify  | 0.70519    | 0.70519    | 0.70519    |   0.0 |  1.10
Other   |            | 0.1037     |            |       |  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:      695484.0 ave      695484 max      695484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695484
Ave neighs/atom = 173.87100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.861344639897, Press = 0.500766273384118
next a
jump SELF top
variable a loop 2000
run 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    -17491.63    -17491.63   -17641.873   -17641.873    290.65596    290.65596    43596.715    43596.715    135.57533    135.57533 
   52000   -17493.359   -17493.359   -17644.916   -17644.916    293.19824    293.19824    43594.609    43594.609    242.25865    242.25865 
Loop time of 64.1975 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.346 ns/day, 17.833 hours/ns, 15.577 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.206     | 63.206     | 63.206     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19778    | 0.19778    | 0.19778    |   0.0 |  0.31
Output  | 0.00017725 | 0.00017725 | 0.00017725 |   0.0 |  0.00
Modify  | 0.69234    | 0.69234    | 0.69234    |   0.0 |  1.08
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:      695796.0 ave      695796 max      695796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695796
Ave neighs/atom = 173.94900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85159826896, Press = -0.37905868258487
next a
jump SELF top
variable a loop 2000
run 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   -17493.359   -17493.359   -17644.916   -17644.916    293.19824    293.19824    43594.609    43594.609    242.25865    242.25865 
   53000   -17487.837   -17487.837   -17641.126   -17641.126    296.54929    296.54929    43598.842    43598.842    146.75714    146.75714 
Loop time of 63.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.358 ns/day, 17.672 hours/ns, 15.718 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.633     | 62.633     | 62.633     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19728    | 0.19728    | 0.19728    |   0.0 |  0.31
Output  | 0.00023185 | 0.00023185 | 0.00023185 |   0.0 |  0.00
Modify  | 0.6887     | 0.6887     | 0.6887     |   0.0 |  1.08
Other   |            | 0.1011     |            |       |  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:      696390.0 ave      696390 max      696390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696390
Ave neighs/atom = 174.09750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826018438766, Press = -0.513642820040115
next a
jump SELF top
variable a loop 2000
run 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   -17487.837   -17487.837   -17641.126   -17641.126    296.54929    296.54929    43598.842    43598.842    146.75714    146.75714 
   54000   -17494.245   -17494.245   -17641.459   -17641.459    284.79548    284.79548    43595.214    43595.214    179.58913    179.58913 
Loop time of 64.1087 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.348 ns/day, 17.808 hours/ns, 15.598 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.114     | 63.114     | 63.114     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19813    | 0.19813    | 0.19813    |   0.0 |  0.31
Output  | 0.00028182 | 0.00028182 | 0.00028182 |   0.0 |  0.00
Modify  | 0.69338    | 0.69338    | 0.69338    |   0.0 |  1.08
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:      696190.0 ave      696190 max      696190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696190
Ave neighs/atom = 174.04750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83012265763, Press = -0.661868732846659
next a
jump SELF top
variable a loop 2000
run 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   -17494.245   -17494.245   -17641.459   -17641.459    284.79548    284.79548    43595.214    43595.214    179.58913    179.58913 
   55000   -17487.158   -17487.158   -17641.281   -17641.281    298.16153    298.16153      43621.1      43621.1   -668.29224   -668.29224 
Loop time of 65.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.328 ns/day, 18.067 hours/ns, 15.375 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.035     | 64.035     | 64.035     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19962    | 0.19962    | 0.19962    |   0.0 |  0.31
Output  | 0.00017832 | 0.00017832 | 0.00017832 |   0.0 |  0.00
Modify  | 0.70378    | 0.70378    | 0.70378    |   0.0 |  1.08
Other   |            | 0.1033     |            |       |  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:      696042.0 ave      696042 max      696042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696042
Ave neighs/atom = 174.01050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.851755136786, Press = -0.705644075031081
next a
jump SELF top
variable a loop 2000
run 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   -17487.158   -17487.158   -17641.281   -17641.281    298.16153    298.16153      43621.1      43621.1   -668.29224   -668.29224 
   56000   -17489.866   -17489.866   -17643.743   -17643.743    297.68457    297.68457    43624.478    43624.478   -836.22988   -836.22988 
Loop time of 64.3249 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.343 ns/day, 17.868 hours/ns, 15.546 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.321     | 63.321     | 63.321     |   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.00017666 | 0.00017666 | 0.00017666 |   0.0 |  0.00
Modify  | 0.70276    | 0.70276    | 0.70276    |   0.0 |  1.09
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:      695980.0 ave      695980 max      695980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695980
Ave neighs/atom = 173.99500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.850403271438, Press = -0.139688623633867
next a
jump SELF top
variable a loop 2000
run 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   -17489.866   -17489.866   -17643.743   -17643.743    297.68457    297.68457    43624.478    43624.478   -836.22988   -836.22988 
   57000   -17495.666   -17495.666   -17643.788   -17643.788    286.55179    286.55179    43576.152    43576.152    769.36065    769.36065 
Loop time of 65.0809 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.328 ns/day, 18.078 hours/ns, 15.365 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.067     | 64.067     | 64.067     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20106    | 0.20106    | 0.20106    |   0.0 |  0.31
Output  | 0.00017622 | 0.00017622 | 0.00017622 |   0.0 |  0.00
Modify  | 0.70925    | 0.70925    | 0.70925    |   0.0 |  1.09
Other   |            | 0.1032     |            |       |  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:      695964.0 ave      695964 max      695964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695964
Ave neighs/atom = 173.99100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83704269988, Press = 0.225836471416302
next a
jump SELF top
variable a loop 2000
run 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   -17495.666   -17495.666   -17643.788   -17643.788    286.55179    286.55179    43576.152    43576.152    769.36065    769.36065 
   58000   -17490.833   -17490.833   -17642.077   -17642.077    292.59184    292.59184    43552.102    43552.102    1824.5862    1824.5862 
Loop time of 64.4729 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.909 hours/ns, 15.510 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.476     | 63.476     | 63.476     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19722    | 0.19722    | 0.19722    |   0.0 |  0.31
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.69686    | 0.69686    | 0.69686    |   0.0 |  1.08
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:      696566.0 ave      696566 max      696566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696566
Ave neighs/atom = 174.14150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815637875122, Press = -0.785509591421084
next a
jump SELF top
variable a loop 2000
run 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   -17490.833   -17490.833   -17642.077   -17642.077    292.59184    292.59184    43552.102    43552.102    1824.5862    1824.5862 
   59000   -17488.057   -17488.057   -17641.132   -17641.132    296.13425    296.13425    43603.857    43603.857   -69.825554   -69.825554 
Loop time of 65.0298 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.329 ns/day, 18.064 hours/ns, 15.378 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.014     | 64.014     | 64.014     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2007     | 0.2007     | 0.2007     |   0.0 |  0.31
Output  | 0.00017523 | 0.00017523 | 0.00017523 |   0.0 |  0.00
Modify  | 0.71182    | 0.71182    | 0.71182    |   0.0 |  1.09
Other   |            | 0.1032     |            |       |  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 = 292.813847788406, Press = -1.44518724546575
next a
jump SELF top
variable a loop 2000
run 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   -17488.057   -17488.057   -17641.132   -17641.132    296.13425    296.13425    43603.857    43603.857   -69.825554   -69.825554 
   60000   -17496.786   -17496.786   -17645.651   -17645.651     287.9895     287.9895    43625.194    43625.194   -985.94924   -985.94924 
Loop time of 65.3205 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.323 ns/day, 18.145 hours/ns, 15.309 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.299     | 64.299     | 64.299     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20384    | 0.20384    | 0.20384    |   0.0 |  0.31
Output  | 0.00022014 | 0.00022014 | 0.00022014 |   0.0 |  0.00
Modify  | 0.71508    | 0.71508    | 0.71508    |   0.0 |  1.09
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:      696090.0 ave      696090 max      696090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696090
Ave neighs/atom = 174.02250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.806871287384, Press = -0.485920535689778
next a
jump SELF top
variable a loop 2000
run 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   -17496.786   -17496.786   -17645.651   -17645.651     287.9895     287.9895    43625.194    43625.194   -985.94924   -985.94924 
   61000   -17489.721   -17489.721   -17641.583   -17641.583    293.78693    293.78693    43612.505    43612.505   -335.65898   -335.65898 
Loop time of 64.8023 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.333 ns/day, 18.001 hours/ns, 15.432 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.789     | 63.789     | 63.789     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19995    | 0.19995    | 0.19995    |   0.0 |  0.31
Output  | 0.00018329 | 0.00018329 | 0.00018329 |   0.0 |  0.00
Modify  | 0.71039    | 0.71039    | 0.71039    |   0.0 |  1.10
Other   |            | 0.1032     |            |       |  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:      696260.0 ave      696260 max      696260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696260
Ave neighs/atom = 174.06500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.778070067921, Press = -0.379283240365812
next a
jump SELF top
variable a loop 2000
run 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   -17489.721   -17489.721   -17641.583   -17641.583    293.78693    293.78693    43612.505    43612.505   -335.65898   -335.65898 
   62000    -17498.52    -17498.52   -17645.646   -17645.646    284.62617    284.62617    43592.846    43592.846    272.00839    272.00839 
Loop time of 64.4923 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.915 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.482     | 63.482     | 63.482     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20016    | 0.20016    | 0.20016    |   0.0 |  0.31
Output  | 0.00017766 | 0.00017766 | 0.00017766 |   0.0 |  0.00
Modify  | 0.70569    | 0.70569    | 0.70569    |   0.0 |  1.09
Other   |            | 0.1045     |            |       |  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:      695816.0 ave      695816 max      695816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695816
Ave neighs/atom = 173.95400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.766632338873, Press = -0.191424571958058
next a
jump SELF top
variable a loop 2000
run 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    -17498.52    -17498.52   -17645.646   -17645.646    284.62617    284.62617    43592.846    43592.846    272.00839    272.00839 
   63000   -17490.336   -17490.336   -17641.431   -17641.431    292.30502    292.30502    43579.485    43579.485    812.31367    812.31367 
Loop time of 64.6234 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.337 ns/day, 17.951 hours/ns, 15.474 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.617     | 63.617     | 63.617     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20049    | 0.20049    | 0.20049    |   0.0 |  0.31
Output  | 0.00022874 | 0.00022874 | 0.00022874 |   0.0 |  0.00
Modify  | 0.70259    | 0.70259    | 0.70259    |   0.0 |  1.09
Other   |            | 0.1033     |            |       |  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:      696492.0 ave      696492 max      696492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696492
Ave neighs/atom = 174.12300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755459813453, Press = -0.146465460252858
next a
jump SELF top
variable a loop 2000
run 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   -17490.336   -17490.336   -17641.431   -17641.431    292.30502    292.30502    43579.485    43579.485    812.31367    812.31367 
   64000   -17491.166   -17491.166   -17641.942   -17641.942    291.68616    291.68616    43544.225    43544.225    2137.7162    2137.7162 
Loop time of 64.7127 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.335 ns/day, 17.976 hours/ns, 15.453 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.701     | 63.701     | 63.701     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19999    | 0.19999    | 0.19999    |   0.0 |  0.31
Output  | 0.0001776  | 0.0001776  | 0.0001776  |   0.0 |  0.00
Modify  | 0.70846    | 0.70846    | 0.70846    |   0.0 |  1.09
Other   |            | 0.1035     |            |       |  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:      696194.0 ave      696194 max      696194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696194
Ave neighs/atom = 174.04850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.75223188235, Press = -1.02728636422174
next a
jump SELF top
variable a loop 2000
run 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   -17491.166   -17491.166   -17641.942   -17641.942    291.68616    291.68616    43544.225    43544.225    2137.7162    2137.7162 
   65000   -17489.966   -17489.966   -17644.849   -17644.849    299.63024    299.63024    43611.972    43611.972    -306.3247    -306.3247 
Loop time of 65.0137 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.329 ns/day, 18.059 hours/ns, 15.381 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.005     | 64.005     | 64.005     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19916    | 0.19916    | 0.19916    |   0.0 |  0.31
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.70653    | 0.70653    | 0.70653    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      696766.0 ave      696766 max      696766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696766
Ave neighs/atom = 174.19150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.766818486588, Press = -1.51694664902328
next a
jump SELF top
variable a loop 2000
run 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   -17489.966   -17489.966   -17644.849   -17644.849    299.63024    299.63024    43611.972    43611.972    -306.3247    -306.3247 
   66000   -17493.979   -17493.979   -17645.706   -17645.706    293.52684    293.52684    43646.468    43646.468   -1745.4268   -1745.4268 
Loop time of 65.5993 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.222 hours/ns, 15.244 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.573     | 64.573     | 64.573     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20197    | 0.20197    | 0.20197    |   0.0 |  0.31
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.72026    | 0.72026    | 0.72026    |   0.0 |  1.10
Other   |            | 0.1042     |            |       |  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:      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 = 292.769407275528, Press = -0.603242166540209
next a
jump SELF top
variable a loop 2000
run 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   -17493.979   -17493.979   -17645.706   -17645.706    293.52684    293.52684    43646.468    43646.468   -1745.4268   -1745.4268 
   67000   -17487.896   -17487.896   -17645.186   -17645.186    304.28943    304.28943    43628.723    43628.723   -848.10607   -848.10607 
Loop time of 64.0492 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.349 ns/day, 17.791 hours/ns, 15.613 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.048     | 63.048     | 63.048     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19789    | 0.19789    | 0.19789    |   0.0 |  0.31
Output  | 0.00045327 | 0.00045327 | 0.00045327 |   0.0 |  0.00
Modify  | 0.70013    | 0.70013    | 0.70013    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      696276.0 ave      696276 max      696276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696276
Ave neighs/atom = 174.06900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.809003304834, Press = 0.0632869052830902
next a
jump SELF top
variable a loop 2000
run 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   -17487.896   -17487.896   -17645.186   -17645.186    304.28943    304.28943    43628.723    43628.723   -848.10607   -848.10607 
   68000   -17492.144   -17492.144   -17643.044   -17643.044    291.92799    291.92799    43589.536    43589.536    415.19928    415.19928 
Loop time of 65.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.323 ns/day, 18.142 hours/ns, 15.311 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.292     | 64.292     | 64.292     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20057    | 0.20057    | 0.20057    |   0.0 |  0.31
Output  | 0.00018087 | 0.00018087 | 0.00018087 |   0.0 |  0.00
Modify  | 0.71509    | 0.71509    | 0.71509    |   0.0 |  1.09
Other   |            | 0.1033     |            |       |  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:      696020.0 ave      696020 max      696020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696020
Ave neighs/atom = 174.00500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813383588446, Press = 0.110149065781539
next a
jump SELF top
variable a loop 2000
run 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   -17492.144   -17492.144   -17643.044   -17643.044    291.92799    291.92799    43589.536    43589.536    415.19928    415.19928 
   69000   -17488.659   -17488.659     -17640.5     -17640.5    293.74826    293.74826    43561.963    43561.963    1554.8735    1554.8735 
Loop time of 65.5276 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.202 hours/ns, 15.261 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.51      | 64.51      | 64.51      |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20068    | 0.20068    | 0.20068    |   0.0 |  0.31
Output  | 0.00018199 | 0.00018199 | 0.00018199 |   0.0 |  0.00
Modify  | 0.71245    | 0.71245    | 0.71245    |   0.0 |  1.09
Other   |            | 0.1047     |            |       |  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:      696282.0 ave      696282 max      696282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696282
Ave neighs/atom = 174.07050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.842511691748, Press = -0.334677509806816
next a
jump SELF top
variable a loop 2000
run 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   -17488.659   -17488.659     -17640.5     -17640.5    293.74826    293.74826    43561.963    43561.963    1554.8735    1554.8735 
   70000   -17493.884   -17493.884     -17644.6     -17644.6     291.5706     291.5706    43588.866    43588.866    492.75456    492.75456 
Loop time of 66.0092 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.309 ns/day, 18.336 hours/ns, 15.149 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.974     | 64.974     | 64.974     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20384    | 0.20384    | 0.20384    |   0.0 |  0.31
Output  | 0.00017441 | 0.00017441 | 0.00017441 |   0.0 |  0.00
Modify  | 0.727      | 0.727      | 0.727      |   0.0 |  1.10
Other   |            | 0.1041     |            |       |  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:      696388.0 ave      696388 max      696388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696388
Ave neighs/atom = 174.09700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84595779708, Press = -1.03070416363426
next a
jump SELF top
variable a loop 2000
run 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   -17493.884   -17493.884     -17644.6     -17644.6     291.5706     291.5706    43588.866    43588.866    492.75456    492.75456 
   71000   -17492.465   -17492.465   -17642.325   -17642.325    289.91299    289.91299    43622.945    43622.945   -753.95605   -753.95605 
Loop time of 63.5751 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.660 hours/ns, 15.729 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.589     | 62.589     | 62.589     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19587    | 0.19587    | 0.19587    |   0.0 |  0.31
Output  | 0.00017672 | 0.00017672 | 0.00017672 |   0.0 |  0.00
Modify  | 0.68719    | 0.68719    | 0.68719    |   0.0 |  1.08
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:      696522.0 ave      696522 max      696522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696522
Ave neighs/atom = 174.13050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845753840814, Press = -0.937981175035165
next a
jump SELF top
variable a loop 2000
run 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   -17492.465   -17492.465   -17642.325   -17642.325    289.91299    289.91299    43622.945    43622.945   -753.95605   -753.95605 
   72000   -17492.958   -17492.958    -17644.12    -17644.12    292.43235    292.43235    43655.619    43655.619    -2042.171    -2042.171 
Loop time of 64.3283 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.343 ns/day, 17.869 hours/ns, 15.545 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.323     | 63.323     | 63.323     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19969    | 0.19969    | 0.19969    |   0.0 |  0.31
Output  | 0.00022253 | 0.00022253 | 0.00022253 |   0.0 |  0.00
Modify  | 0.70213    | 0.70213    | 0.70213    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      695866.0 ave      695866 max      695866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695866
Ave neighs/atom = 173.96650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.814083911603, Press = -0.384293401775184
next a
jump SELF top
variable a loop 2000
run 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   -17492.958   -17492.958    -17644.12    -17644.12    292.43235    292.43235    43655.619    43655.619    -2042.171    -2042.171 
   73000   -17492.135   -17492.135   -17642.422   -17642.422    290.74074    290.74074    43625.232    43625.232   -1030.0285   -1030.0285 
Loop time of 63.6649 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.357 ns/day, 17.685 hours/ns, 15.707 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.677     | 62.677     | 62.677     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19762    | 0.19762    | 0.19762    |   0.0 |  0.31
Output  | 0.00017712 | 0.00017712 | 0.00017712 |   0.0 |  0.00
Modify  | 0.68799    | 0.68799    | 0.68799    |   0.0 |  1.08
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:      695896.0 ave      695896 max      695896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695896
Ave neighs/atom = 173.97400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.804252120678, Press = 0.648039422127233
next a
jump SELF top
variable a loop 2000
run 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   -17492.135   -17492.135   -17642.422   -17642.422    290.74074    290.74074    43625.232    43625.232   -1030.0285   -1030.0285 
   74000   -17490.778   -17490.778   -17642.489   -17642.489    293.49581    293.49581    43571.615    43571.615    1139.2117    1139.2117 
Loop time of 64.2664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.344 ns/day, 17.852 hours/ns, 15.560 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.266     | 63.266     | 63.266     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19929    | 0.19929    | 0.19929    |   0.0 |  0.31
Output  | 0.00017726 | 0.00017726 | 0.00017726 |   0.0 |  0.00
Modify  | 0.69731    | 0.69731    | 0.69731    |   0.0 |  1.09
Other   |            | 0.1035     |            |       |  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:      695768.0 ave      695768 max      695768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695768
Ave neighs/atom = 173.94200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.777776469655, Press = 0.0910375027768197
next a
jump SELF top
variable a loop 2000
run 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   -17490.778   -17490.778   -17642.489   -17642.489    293.49581    293.49581    43571.615    43571.615    1139.2117    1139.2117 
   75000   -17493.754   -17493.754   -17645.213   -17645.213    293.00798    293.00798    43569.927    43569.927    1217.5426    1217.5426 
Loop time of 63.9131 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.352 ns/day, 17.754 hours/ns, 15.646 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.924     | 62.924     | 62.924     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19677    | 0.19677    | 0.19677    |   0.0 |  0.31
Output  | 0.00017796 | 0.00017796 | 0.00017796 |   0.0 |  0.00
Modify  | 0.69001    | 0.69001    | 0.69001    |   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:      696374.0 ave      696374 max      696374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696374
Ave neighs/atom = 174.09350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776255327389, Press = -0.273088921365546
next a
jump SELF top
variable a loop 2000
run 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   -17493.754   -17493.754   -17645.213   -17645.213    293.00798    293.00798    43569.927    43569.927    1217.5426    1217.5426 
   76000   -17491.522   -17491.522   -17642.596   -17642.596    292.26323    292.26323    43587.274    43587.274    507.85193    507.85193 
Loop time of 63.9039 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.352 ns/day, 17.751 hours/ns, 15.648 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.913     | 62.913     | 62.913     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19751    | 0.19751    | 0.19751    |   0.0 |  0.31
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.69116    | 0.69116    | 0.69116    |   0.0 |  1.08
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:      696822.0 ave      696822 max      696822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696822
Ave neighs/atom = 174.20550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.786118738248, Press = -0.761875198228734
next a
jump SELF top
variable a loop 2000
run 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   -17491.522   -17491.522   -17642.596   -17642.596    292.26323    292.26323    43587.274    43587.274    507.85193    507.85193 
   77000    -17485.65    -17485.65   -17639.628   -17639.628    297.88041    297.88041    43634.506    43634.506   -1160.9078   -1160.9078 
Loop time of 64.4334 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.424     | 63.424     | 63.424     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20081    | 0.20081    | 0.20081    |   0.0 |  0.31
Output  | 0.00018023 | 0.00018023 | 0.00018023 |   0.0 |  0.00
Modify  | 0.70544    | 0.70544    | 0.70544    |   0.0 |  1.09
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:      696136.0 ave      696136 max      696136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696136
Ave neighs/atom = 174.03400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.795622953645, Press = -0.818781827231321
next a
jump SELF top
variable a loop 2000
run 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    -17485.65    -17485.65   -17639.628   -17639.628    297.88041    297.88041    43634.506    43634.506   -1160.9078   -1160.9078 
   78000   -17492.814   -17492.814   -17643.397   -17643.397    291.31397    291.31397    43656.405    43656.405   -2051.0396   -2051.0396 
Loop time of 64.4696 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.908 hours/ns, 15.511 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.468     | 63.468     | 63.468     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19915    | 0.19915    | 0.19915    |   0.0 |  0.31
Output  | 0.00017285 | 0.00017285 | 0.00017285 |   0.0 |  0.00
Modify  | 0.69926    | 0.69926    | 0.69926    |   0.0 |  1.08
Other   |            | 0.1032     |            |       |  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:      695788.0 ave      695788 max      695788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695788
Ave neighs/atom = 173.94700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819474263077, Press = -0.205547960772285
next a
jump SELF top
variable a loop 2000
run 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   -17492.814   -17492.814   -17643.397   -17643.397    291.31397    291.31397    43656.405    43656.405   -2051.0396   -2051.0396 
   79000   -17484.682   -17484.682    -17638.35    -17638.35    297.28074    297.28074     43610.44     43610.44   -294.51291   -294.51291 
Loop time of 63.4283 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.619 hours/ns, 15.766 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.446     | 62.446     | 62.446     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19513    | 0.19513    | 0.19513    |   0.0 |  0.31
Output  | 0.00017921 | 0.00017921 | 0.00017921 |   0.0 |  0.00
Modify  | 0.6845     | 0.6845     | 0.6845     |   0.0 |  1.08
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:      695428.0 ave      695428 max      695428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695428
Ave neighs/atom = 173.85700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.846571621258, Press = 1.35965511851834
next a
jump SELF top
variable a loop 2000
run 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 
   79000   -17484.682   -17484.682    -17638.35    -17638.35    297.28074    297.28074     43610.44     43610.44   -294.51291   -294.51291 
   80000   -17491.297   -17491.297    -17642.09    -17642.09    291.71943    291.71943    43564.375    43564.375    1328.7093    1328.7093 
Loop time of 63.5592 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.655 hours/ns, 15.733 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.557     | 62.557     | 62.557     |   0.0 | 98.42
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19825    | 0.19825    | 0.19825    |   0.0 |  0.31
Output  | 0.00017752 | 0.00017752 | 0.00017752 |   0.0 |  0.00
Modify  | 0.7002     | 0.7002     | 0.7002     |   0.0 |  1.10
Other   |            | 0.1032     |            |       |  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:      695478.0 ave      695478 max      695478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695478
Ave neighs/atom = 173.86950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.86379415465, Press = 0.0407032241730971
next a
jump SELF top
variable a loop 2000
run 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 
   80000   -17491.297   -17491.297    -17642.09    -17642.09    291.71943    291.71943    43564.375    43564.375    1328.7093    1328.7093 
   81000   -17490.081   -17490.081   -17642.455   -17642.455    294.77765    294.77765    43578.823    43578.823    876.28652    876.28652 
Loop time of 64.1438 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.347 ns/day, 17.818 hours/ns, 15.590 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.142     | 63.142     | 63.142     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19777    | 0.19777    | 0.19777    |   0.0 |  0.31
Output  | 0.00017715 | 0.00017715 | 0.00017715 |   0.0 |  0.00
Modify  | 0.70055    | 0.70055    | 0.70055    |   0.0 |  1.09
Other   |            | 0.1038     |            |       |  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:      696448.0 ave      696448 max      696448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696448
Ave neighs/atom = 174.11200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884374423807, Press = -0.605182189443526
next a
jump SELF top
variable a loop 2000
run 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 
   81000   -17490.081   -17490.081   -17642.455   -17642.455    294.77765    294.77765    43578.823    43578.823    876.28652    876.28652 
   82000   -17496.318   -17496.318   -17642.169   -17642.169    282.16057    282.16057    43604.778    43604.778   -200.30356   -200.30356 
Loop time of 63.8644 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.740 hours/ns, 15.658 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.868     | 62.868     | 62.868     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19692    | 0.19692    | 0.19692    |   0.0 |  0.31
Output  | 0.00017669 | 0.00017669 | 0.00017669 |   0.0 |  0.00
Modify  | 0.69651    | 0.69651    | 0.69651    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      696448.0 ave      696448 max      696448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696448
Ave neighs/atom = 174.11200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.865400514347, Press = -0.647841419888747
next a
jump SELF top
variable a loop 2000
run 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 
   82000   -17496.318   -17496.318   -17642.169   -17642.169    282.16057    282.16057    43604.778    43604.778   -200.30356   -200.30356 
   83000   -17492.108   -17492.108   -17642.113   -17642.113    290.19556    290.19556    43648.203    43648.203   -1780.5552   -1780.5552 
Loop time of 63.4898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.636 hours/ns, 15.751 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.504     | 62.504     | 62.504     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19462    | 0.19462    | 0.19462    |   0.0 |  0.31
Output  | 0.00017756 | 0.00017756 | 0.00017756 |   0.0 |  0.00
Modify  | 0.68885    | 0.68885    | 0.68885    |   0.0 |  1.08
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:      696046.0 ave      696046 max      696046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696046
Ave neighs/atom = 174.01150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.868542437851, Press = -0.546133022987143
next a
jump SELF top
variable a loop 2000
run 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 
   83000   -17492.108   -17492.108   -17642.113   -17642.113    290.19556    290.19556    43648.203    43648.203   -1780.5552   -1780.5552 
   84000   -17492.841   -17492.841   -17645.357   -17645.357    295.05315    295.05315    43642.498    43642.498   -1409.6107   -1409.6107 
Loop time of 64.0235 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.784 hours/ns, 15.619 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.031     | 63.031     | 63.031     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19764    | 0.19764    | 0.19764    |   0.0 |  0.31
Output  | 0.00022428 | 0.00022428 | 0.00022428 |   0.0 |  0.00
Modify  | 0.69141    | 0.69141    | 0.69141    |   0.0 |  1.08
Other   |            | 0.1029     |            |       |  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:      695088.0 ave      695088 max      695088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695088
Ave neighs/atom = 173.77200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888300907698, Press = 0.495513660681577
next a
jump SELF top
variable a loop 2000
run 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 
   84000   -17492.841   -17492.841   -17645.357   -17645.357    295.05315    295.05315    43642.498    43642.498   -1409.6107   -1409.6107 
   85000   -17489.221   -17489.221   -17642.924   -17642.924    297.34814    297.34814    43569.823    43569.823    1220.7094    1220.7094 
Loop time of 63.8063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.354 ns/day, 17.724 hours/ns, 15.672 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.816     | 62.816     | 62.816     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19709    | 0.19709    | 0.19709    |   0.0 |  0.31
Output  | 0.00017812 | 0.00017812 | 0.00017812 |   0.0 |  0.00
Modify  | 0.69047    | 0.69047    | 0.69047    |   0.0 |  1.08
Other   |            | 0.1029     |            |       |  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:      695646.0 ave      695646 max      695646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695646
Ave neighs/atom = 173.91150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89031697019, Press = 0.380681722876984
next a
jump SELF top
variable a loop 2000
run 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 
   85000   -17489.221   -17489.221   -17642.924   -17642.924    297.34814    297.34814    43569.823    43569.823    1220.7094    1220.7094 
   86000   -17492.074   -17492.074   -17642.151   -17642.151     290.3359     290.3359    43582.318    43582.318    574.58807    574.58807 
Loop time of 63.8443 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.735 hours/ns, 15.663 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.845     | 62.845     | 62.845     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19784    | 0.19784    | 0.19784    |   0.0 |  0.31
Output  | 0.00017895 | 0.00017895 | 0.00017895 |   0.0 |  0.00
Modify  | 0.69796    | 0.69796    | 0.69796    |   0.0 |  1.09
Other   |            | 0.1036     |            |       |  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:      696328.0 ave      696328 max      696328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696328
Ave neighs/atom = 174.08200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.868775894965, Press = -0.359000364182234
next a
jump SELF top
variable a loop 2000
run 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 
   86000   -17492.074   -17492.074   -17642.151   -17642.151     290.3359     290.3359    43582.318    43582.318    574.58807    574.58807 
   87000   -17489.657   -17489.657   -17639.689   -17639.689    290.24717    290.24717    43606.438    43606.438   -137.28089   -137.28089 
Loop time of 64.4892 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.19895    | 0.19895    | 0.19895    |   0.0 |  0.31
Output  | 0.00017745 | 0.00017745 | 0.00017745 |   0.0 |  0.00
Modify  | 0.69958    | 0.69958    | 0.69958    |   0.0 |  1.08
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:      696254.0 ave      696254 max      696254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696254
Ave neighs/atom = 174.06350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.880749069749, Press = -0.423076495682633
next a
jump SELF top
variable a loop 2000
run 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 
   87000   -17489.657   -17489.657   -17639.689   -17639.689    290.24717    290.24717    43606.438    43606.438   -137.28089   -137.28089 
   88000   -17491.886   -17491.886   -17643.068   -17643.068    292.47211    292.47211    43630.121    43630.121   -1157.7188   -1157.7188 
Loop time of 63.0846 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.370 ns/day, 17.524 hours/ns, 15.852 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.097     | 62.097     | 62.097     |   0.0 | 98.43
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19653    | 0.19653    | 0.19653    |   0.0 |  0.31
Output  | 0.00017876 | 0.00017876 | 0.00017876 |   0.0 |  0.00
Modify  | 0.68838    | 0.68838    | 0.68838    |   0.0 |  1.09
Other   |            | 0.1029     |            |       |  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:      695624.0 ave      695624 max      695624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695624
Ave neighs/atom = 173.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900356606118, Press = -0.302738124390579
next a
jump SELF top
variable a loop 2000
run 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 
   88000   -17491.886   -17491.886   -17643.068   -17643.068    292.47211    292.47211    43630.121    43630.121   -1157.7188   -1157.7188 
   89000   -17489.537   -17489.537   -17642.218   -17642.218    295.37245    295.37245    43631.031    43631.031   -1103.9671   -1103.9671 
Loop time of 63.4294 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.619 hours/ns, 15.766 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.439     | 62.439     | 62.439     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19541    | 0.19541    | 0.19541    |   0.0 |  0.31
Output  | 0.0001784  | 0.0001784  | 0.0001784  |   0.0 |  0.00
Modify  | 0.69251    | 0.69251    | 0.69251    |   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:      695380.0 ave      695380 max      695380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695380
Ave neighs/atom = 173.84500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925654213918, Press = 0.264295646668984
next a
jump SELF top
variable a loop 2000
run 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 
   89000   -17489.537   -17489.537   -17642.218   -17642.218    295.37245    295.37245    43631.031    43631.031   -1103.9671   -1103.9671 
   90000   -17493.255   -17493.255    -17645.34    -17645.34    294.21995    294.21995    43571.787    43571.787    1135.1044    1135.1044 
Loop time of 63.1464 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.541 hours/ns, 15.836 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.16      | 62.16      | 62.16      |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19688    | 0.19688    | 0.19688    |   0.0 |  0.31
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.68619    | 0.68619    | 0.68619    |   0.0 |  1.09
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:      695154.0 ave      695154 max      695154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695154
Ave neighs/atom = 173.78850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.934128121148, Press = 0.500237991680979
next a
jump SELF top
variable a loop 2000
run 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 
   90000   -17493.255   -17493.255    -17645.34    -17645.34    294.21995    294.21995    43571.787    43571.787    1135.1044    1135.1044 
   91000   -17488.686   -17488.686   -17643.022   -17643.022     298.5734     298.5734    43540.753    43540.753      2365.54      2365.54 
Loop time of 63.4942 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.637 hours/ns, 15.749 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.503     | 62.503     | 62.503     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19756    | 0.19756    | 0.19756    |   0.0 |  0.31
Output  | 0.000197   | 0.000197   | 0.000197   |   0.0 |  0.00
Modify  | 0.69113    | 0.69113    | 0.69113    |   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:      696364.0 ave      696364 max      696364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696364
Ave neighs/atom = 174.09100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.938421998376, Press = -0.19803879836822
next a
jump SELF top
variable a loop 2000
run 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 
   91000   -17488.686   -17488.686   -17643.022   -17643.022     298.5734     298.5734    43540.753    43540.753      2365.54      2365.54 
   92000   -17492.077   -17492.077   -17641.264   -17641.264    288.61187    288.61187    43586.711    43586.711    456.85343    456.85343 
Loop time of 63.7419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.355 ns/day, 17.706 hours/ns, 15.688 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.752     | 62.752     | 62.752     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19758    | 0.19758    | 0.19758    |   0.0 |  0.31
Output  | 0.00022224 | 0.00022224 | 0.00022224 |   0.0 |  0.00
Modify  | 0.69006    | 0.69006    | 0.69006    |   0.0 |  1.08
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:      696514.0 ave      696514 max      696514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696514
Ave neighs/atom = 174.12850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.939278518714, Press = -0.465061658436243
next a
jump SELF top
variable a loop 2000
run 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 
   92000   -17492.077   -17492.077   -17641.264   -17641.264    288.61187    288.61187    43586.711    43586.711    456.85343    456.85343 
   93000   -17485.669   -17485.669   -17640.334   -17640.334    299.21096    299.21096    43620.486    43620.486   -669.86564   -669.86564 
Loop time of 64.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.339 ns/day, 17.928 hours/ns, 15.494 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.539     | 63.539     | 63.539     |   0.0 | 98.45
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19939    | 0.19939    | 0.19939    |   0.0 |  0.31
Output  | 0.00047438 | 0.00047438 | 0.00047438 |   0.0 |  0.00
Modify  | 0.69942    | 0.69942    | 0.69942    |   0.0 |  1.08
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:      695812.0 ave      695812 max      695812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695812
Ave neighs/atom = 173.95300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.962533049045, Press = -0.566483956008829
next a
jump SELF top
variable a loop 2000
run 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 
   93000   -17485.669   -17485.669   -17640.334   -17640.334    299.21096    299.21096    43620.486    43620.486   -669.86564   -669.86564 
   94000   -17493.141   -17493.141   -17645.439   -17645.439    294.63023    294.63023    43637.698    43637.698    -1260.586    -1260.586 
Loop time of 63.4659 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.629 hours/ns, 15.756 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.475     | 62.475     | 62.475     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19638    | 0.19638    | 0.19638    |   0.0 |  0.31
Output  | 0.00026217 | 0.00026217 | 0.00026217 |   0.0 |  0.00
Modify  | 0.69128    | 0.69128    | 0.69128    |   0.0 |  1.09
Other   |            | 0.1029     |            |       |  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:      695514.0 ave      695514 max      695514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695514
Ave neighs/atom = 173.87850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.972468507651, Press = -0.206516981857586
next a
jump SELF top
variable a loop 2000
run 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 
   94000   -17493.141   -17493.141   -17645.439   -17645.439    294.63023    294.63023    43637.698    43637.698    -1260.586    -1260.586 
   95000   -17491.152   -17491.152   -17642.633   -17642.633    293.04984    293.04984    43616.465    43616.465   -513.40764   -513.40764 
Loop time of 63.299 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.583 hours/ns, 15.798 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.311     | 62.311     | 62.311     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19689    | 0.19689    | 0.19689    |   0.0 |  0.31
Output  | 0.00017819 | 0.00017819 | 0.00017819 |   0.0 |  0.00
Modify  | 0.68832    | 0.68832    | 0.68832    |   0.0 |  1.09
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:      695570.0 ave      695570 max      695570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695570
Ave neighs/atom = 173.89250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.979806600972, Press = 0.363564764105043
next a
jump SELF top
variable a loop 2000
run 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 
   95000   -17491.152   -17491.152   -17642.633   -17642.633    293.04984    293.04984    43616.465    43616.465   -513.40764   -513.40764 
   96000   -17489.076   -17489.076   -17643.222   -17643.222     298.2054     298.2054    43539.881    43539.881    2407.9131    2407.9131 
Loop time of 64.0015 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.350 ns/day, 17.778 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    | 63.003     | 63.003     | 63.003     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19959    | 0.19959    | 0.19959    |   0.0 |  0.31
Output  | 0.00017773 | 0.00017773 | 0.00017773 |   0.0 |  0.00
Modify  | 0.69614    | 0.69614    | 0.69614    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      695496.0 ave      695496 max      695496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695496
Ave neighs/atom = 173.87400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.977475198613, Press = 0.254354533508422
next a
jump SELF top
variable a loop 2000
run 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 
   96000   -17489.076   -17489.076   -17643.222   -17643.222     298.2054     298.2054    43539.881    43539.881    2407.9131    2407.9131 
   97000     -17492.9     -17492.9   -17642.267   -17642.267    288.96066    288.96066    43559.409    43559.409    1543.9997    1543.9997 
Loop time of 63.3431 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.595 hours/ns, 15.787 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.357     | 62.357     | 62.357     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1963     | 0.1963     | 0.1963     |   0.0 |  0.31
Output  | 0.00022733 | 0.00022733 | 0.00022733 |   0.0 |  0.00
Modify  | 0.68708    | 0.68708    | 0.68708    |   0.0 |  1.08
Other   |            | 0.103      |            |       |  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:      696558.0 ave      696558 max      696558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696558
Ave neighs/atom = 174.13950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.987683832627, Press = -0.511240493769157
next a
jump SELF top
variable a loop 2000
run 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 
   97000     -17492.9     -17492.9   -17642.267   -17642.267    288.96066    288.96066    43559.409    43559.409    1543.9997    1543.9997 
   98000   -17487.783   -17487.783   -17642.218   -17642.218    298.76463    298.76463    43603.656    43603.656     2.431012     2.431012 
Loop time of 63.8656 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.740 hours/ns, 15.658 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.866     | 62.866     | 62.866     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19988    | 0.19988    | 0.19988    |   0.0 |  0.31
Output  | 0.00017374 | 0.00017374 | 0.00017374 |   0.0 |  0.00
Modify  | 0.69624    | 0.69624    | 0.69624    |   0.0 |  1.09
Other   |            | 0.1031     |            |       |  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:      696464.0 ave      696464 max      696464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696464
Ave neighs/atom = 174.11600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.011503502884, Press = -0.414098232930017
next a
jump SELF top
variable a loop 2000
run 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 
   98000   -17487.783   -17487.783   -17642.218   -17642.218    298.76463    298.76463    43603.656    43603.656     2.431012     2.431012 
   99000   -17488.857   -17488.857   -17642.283   -17642.283    296.81274    296.81274    43609.024    43609.024   -207.15512   -207.15512 
Loop time of 63.9011 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.352 ns/day, 17.750 hours/ns, 15.649 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.904     | 62.904     | 62.904     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19823    | 0.19823    | 0.19823    |   0.0 |  0.31
Output  | 0.000274   | 0.000274   | 0.000274   |   0.0 |  0.00
Modify  | 0.69557    | 0.69557    | 0.69557    |   0.0 |  1.09
Other   |            | 0.1034     |            |       |  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:      695954.0 ave      695954 max      695954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695954
Ave neighs/atom = 173.98850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.020596807981, Press = -0.323164932820519
next a
jump SELF top
variable a loop 2000
run 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 
   99000   -17488.857   -17488.857   -17642.283   -17642.283    296.81274    296.81274    43609.024    43609.024   -207.15512   -207.15512 
  100000   -17493.916   -17493.916   -17645.501   -17645.501    293.25206    293.25206    43605.174    43605.174   -87.145874   -87.145874 
Loop time of 63.1118 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.369 ns/day, 17.531 hours/ns, 15.845 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.128     | 62.128     | 62.128     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19619    | 0.19619    | 0.19619    |   0.0 |  0.31
Output  | 0.00017859 | 0.00017859 | 0.00017859 |   0.0 |  0.00
Modify  | 0.68424    | 0.68424    | 0.68424    |   0.0 |  1.08
Other   |            | 0.1031     |            |       |  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:      695668.0 ave      695668 max      695668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695668
Ave neighs/atom = 173.91700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.019591059841, Press = -0.26221900123921
next a
jump SELF top
variable a loop 2000
run 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 
  100000   -17493.916   -17493.916   -17645.501   -17645.501    293.25206    293.25206    43605.174    43605.174   -87.145874   -87.145874 
  101000   -17491.227   -17491.227   -17641.676   -17641.676    291.05364    291.05364    43595.073    43595.073    138.18516    138.18516 
Loop time of 63.5197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.644 hours/ns, 15.743 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.528     | 62.528     | 62.528     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19779    | 0.19779    | 0.19779    |   0.0 |  0.31
Output  | 0.00022409 | 0.00022409 | 0.00022409 |   0.0 |  0.00
Modify  | 0.69159    | 0.69159    | 0.69159    |   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:      696120.0 ave      696120 max      696120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696120
Ave neighs/atom = 174.03000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.016432624104, Press = -0.232288764217698
next a
jump SELF top
variable a loop 2000
run 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 
  101000   -17491.227   -17491.227   -17641.676   -17641.676    291.05364    291.05364    43595.073    43595.073    138.18516    138.18516 
  102000   -17493.126   -17493.126   -17645.005   -17645.005    293.82087    293.82087    43597.262    43597.262    334.80462    334.80462 
Loop time of 62.9919 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.372 ns/day, 17.498 hours/ns, 15.875 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.011     | 62.011     | 62.011     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19095    | 0.19095    | 0.19095    |   0.0 |  0.30
Output  | 0.00023026 | 0.00023026 | 0.00023026 |   0.0 |  0.00
Modify  | 0.68809    | 0.68809    | 0.68809    |   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:      695682.0 ave      695682 max      695682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 695682
Ave neighs/atom = 173.92050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.992668695184, Press = -0.217110568591694
next a
jump SELF top
variable a loop 2000
run 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 
  102000   -17493.126   -17493.126   -17645.005   -17645.005    293.82087    293.82087    43597.262    43597.262    334.80462    334.80462 
  103000   -17493.521   -17493.521   -17642.842   -17642.842     288.8725     288.8725    43606.521    43606.521   -260.21894   -260.21894 
Loop time of 62.7238 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.377 ns/day, 17.423 hours/ns, 15.943 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    | 61.747     | 61.747     | 61.747     |   0.0 | 98.44
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19224    | 0.19224    | 0.19224    |   0.0 |  0.31
Output  | 0.00023086 | 0.00023086 | 0.00023086 |   0.0 |  0.00
Modify  | 0.68293    | 0.68293    | 0.68293    |   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:      696244.0 ave      696244 max      696244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 696244
Ave neighs/atom = 174.06100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
43601.7086534374

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0