# 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.143073618412018*${_u_distance}
variable latticeconst_converted equal 3.143073618412018*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14307361841202
Lattice spacing in x,y,z = 3.1430736 3.1430736 3.1430736
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 (31.430736 31.430736 31.430736)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (31.430736 31.430736 31.430736)
  create_atoms CPU = 0.002 seconds

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

kim_interactions W

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

kim interactions W
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_SetyawanGaoKurtz_2018_ReW__MO_680820064987_000
pair_coeff * * W
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 183.84

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_680820064987_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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17720.365   -17720.365    -17801.28    -17801.28       313.15       313.15    31050.147    31050.147    2783.4357    2783.4357 
    1000   -17656.772   -17656.772   -17734.727   -17734.727    301.69555    301.69555    31313.216    31313.216    108.70493    108.70493 
Loop time of 25.6624 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.367 ns/day, 7.128 hours/ns, 38.968 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    | 25.128     | 25.128     | 25.128     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.40
Output  | 0.00024585 | 0.00024585 | 0.00024585 |   0.0 |  0.00
Modify  | 0.36786    | 0.36786    | 0.36786    |   0.0 |  1.43
Other   |            | 0.06391    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17656.772   -17656.772   -17734.727   -17734.727    301.69555    301.69555    31313.216    31313.216    108.70493    108.70493 
    2000   -17647.972   -17647.972   -17733.161   -17733.161    329.68931    329.68931    31318.188    31318.188   -68.618326   -68.618326 
Loop time of 25.3019 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.415 ns/day, 7.028 hours/ns, 39.523 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    | 24.792     | 24.792     | 24.792     |   0.0 | 97.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098346   | 0.098346   | 0.098346   |   0.0 |  0.39
Output  | 0.00019745 | 0.00019745 | 0.00019745 |   0.0 |  0.00
Modify  | 0.34956    | 0.34956    | 0.34956    |   0.0 |  1.38
Other   |            | 0.0622     |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17647.972   -17647.972   -17733.161   -17733.161    329.68931    329.68931    31318.188    31318.188   -68.618326   -68.618326 
    3000   -17652.907   -17652.907   -17734.904   -17734.904    317.33904    317.33904    31328.913    31328.913   -2076.4608   -2076.4608 
Loop time of 25.4379 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.397 ns/day, 7.066 hours/ns, 39.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    | 24.926     | 24.926     | 24.926     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099408   | 0.099408   | 0.099408   |   0.0 |  0.39
Output  | 0.00018855 | 0.00018855 | 0.00018855 |   0.0 |  0.00
Modify  | 0.3505     | 0.3505     | 0.3505     |   0.0 |  1.38
Other   |            | 0.06222    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17652.907   -17652.907   -17734.904   -17734.904    317.33904    317.33904    31328.913    31328.913   -2076.4608   -2076.4608 
    4000   -17653.106   -17653.106   -17733.557   -17733.557    311.35566    311.35566    31292.627    31292.627    4015.4249    4015.4249 
Loop time of 25.3466 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.409 ns/day, 7.041 hours/ns, 39.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    | 24.837     | 24.837     | 24.837     |   0.0 | 97.99
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099095   | 0.099095   | 0.099095   |   0.0 |  0.39
Output  | 0.00019563 | 0.00019563 | 0.00019563 |   0.0 |  0.00
Modify  | 0.34841    | 0.34841    | 0.34841    |   0.0 |  1.37
Other   |            | 0.06173    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17653.106   -17653.106   -17733.557   -17733.557    311.35566    311.35566    31292.627    31292.627    4015.4249    4015.4249 
    5000    -17650.14    -17650.14   -17733.492   -17733.492    322.58186    322.58186    31340.726    31340.726   -3398.0396   -3398.0396 
Loop time of 25.1804 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.431 ns/day, 6.995 hours/ns, 39.713 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.669     | 24.669     | 24.669     |   0.0 | 97.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098117   | 0.098117   | 0.098117   |   0.0 |  0.39
Output  | 0.0001594  | 0.0001594  | 0.0001594  |   0.0 |  0.00
Modify  | 0.35083    | 0.35083    | 0.35083    |   0.0 |  1.39
Other   |            | 0.06203    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 319.275433253331, Press = -30.1909349617025
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -17650.14    -17650.14   -17733.492   -17733.492    322.58186    322.58186    31340.726    31340.726   -3398.0396   -3398.0396 
    6000   -17653.702   -17653.702   -17733.354   -17733.354    308.26318    308.26318    31302.153    31302.153     1319.191     1319.191 
Loop time of 25.1586 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.434 ns/day, 6.988 hours/ns, 39.748 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    | 24.637     | 24.637     | 24.637     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097265   | 0.097265   | 0.097265   |   0.0 |  0.39
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.3628     | 0.3628     | 0.3628     |   0.0 |  1.44
Other   |            | 0.0616     |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.811776064568, Press = -10.4150506985494
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17653.702   -17653.702   -17733.354   -17733.354    308.26318    308.26318    31302.153    31302.153     1319.191     1319.191 
    7000    -17649.15    -17649.15   -17732.546   -17732.546    322.74886    322.74886    31362.927    31362.927   -5343.1542   -5343.1542 
Loop time of 25.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.403 ns/day, 7.052 hours/ns, 39.390 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    | 24.862     | 24.862     | 24.862     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097805   | 0.097805   | 0.097805   |   0.0 |  0.39
Output  | 0.00019486 | 0.00019486 | 0.00019486 |   0.0 |  0.00
Modify  | 0.36563    | 0.36563    | 0.36563    |   0.0 |  1.44
Other   |            | 0.06169    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 314.636405604881, Press = 22.8961860457962
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -17649.15    -17649.15   -17732.546   -17732.546    322.74886    322.74886    31362.927    31362.927   -5343.1542   -5343.1542 
    8000   -17650.799   -17650.799   -17731.431   -17731.431     312.0546     312.0546    31311.645    31311.645    1233.8168    1233.8168 
Loop time of 25.4558 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.394 ns/day, 7.071 hours/ns, 39.284 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    | 24.924     | 24.924     | 24.924     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098667   | 0.098667   | 0.098667   |   0.0 |  0.39
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.37039    | 0.37039    | 0.37039    |   0.0 |  1.46
Other   |            | 0.0622     |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.872204973839, Press = 3.07978868269639
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17650.799   -17650.799   -17731.431   -17731.431     312.0546     312.0546    31311.645    31311.645    1233.8168    1233.8168 
    9000   -17652.199   -17652.199   -17732.344   -17732.344    310.17075    310.17075    31324.423    31324.423    163.61945    163.61945 
Loop time of 25.4774 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.391 ns/day, 7.077 hours/ns, 39.251 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    | 24.949     | 24.949     | 24.949     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098193   | 0.098193   | 0.098193   |   0.0 |  0.39
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.3682     | 0.3682     | 0.3682     |   0.0 |  1.45
Other   |            | 0.06214    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.811766805971, Press = -4.39346536136242
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17652.199   -17652.199   -17732.344   -17732.344    310.17075    310.17075    31324.423    31324.423    163.61945    163.61945 
   10000   -17649.703   -17649.703   -17731.384   -17731.384    316.11454    316.11454    31339.145    31339.145   -2808.3962   -2808.3962 
Loop time of 25.4244 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.398 ns/day, 7.062 hours/ns, 39.332 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    | 24.896     | 24.896     | 24.896     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097956   | 0.097956   | 0.097956   |   0.0 |  0.39
Output  | 0.00015279 | 0.00015279 | 0.00015279 |   0.0 |  0.00
Modify  | 0.36814    | 0.36814    | 0.36814    |   0.0 |  1.45
Other   |            | 0.06183    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.511495681244, Press = -11.7680765597518
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17649.703   -17649.703   -17731.384   -17731.384    316.11454    316.11454    31339.145    31339.145   -2808.3962   -2808.3962 
   11000    -17651.21    -17651.21   -17733.098   -17733.098    316.91443    316.91443    31342.877    31342.877   -3652.3795   -3652.3795 
Loop time of 25.4408 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.396 ns/day, 7.067 hours/ns, 39.307 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    | 24.915     | 24.915     | 24.915     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097703   | 0.097703   | 0.097703   |   0.0 |  0.38
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.36607    | 0.36607    | 0.36607    |   0.0 |  1.44
Other   |            | 0.06218    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.51118201421, Press = -4.9684422125472
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -17651.21    -17651.21   -17733.098   -17733.098    316.91443    316.91443    31342.877    31342.877   -3652.3795   -3652.3795 
   12000   -17652.321   -17652.321   -17732.488   -17732.488    310.25232    310.25232    31309.534    31309.534    1210.9519    1210.9519 
Loop time of 25.3938 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.402 ns/day, 7.054 hours/ns, 39.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    | 24.865     | 24.865     | 24.865     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09854    | 0.09854    | 0.09854    |   0.0 |  0.39
Output  | 0.00015191 | 0.00015191 | 0.00015191 |   0.0 |  0.00
Modify  | 0.36813    | 0.36813    | 0.36813    |   0.0 |  1.45
Other   |            | 0.06179    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.789104841198, Press = -3.53543787695685
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17652.321   -17652.321   -17732.488   -17732.488    310.25232    310.25232    31309.534    31309.534    1210.9519    1210.9519 
   13000   -17647.462   -17647.462    -17729.87    -17729.87    318.92822    318.92822     31352.65     31352.65   -3488.7141   -3488.7141 
Loop time of 25.4487 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.395 ns/day, 7.069 hours/ns, 39.295 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    | 24.919     | 24.919     | 24.919     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098258   | 0.098258   | 0.098258   |   0.0 |  0.39
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.36889    | 0.36889    | 0.36889    |   0.0 |  1.45
Other   |            | 0.06212    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.719476316463, Press = 3.99719216832311
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17647.462   -17647.462    -17729.87    -17729.87    318.92822    318.92822     31352.65     31352.65   -3488.7141   -3488.7141 
   14000   -17652.784   -17652.784   -17732.626   -17732.626    308.99583    308.99583    31318.952    31318.952   -399.14442   -399.14442 
Loop time of 25.1222 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.439 ns/day, 6.978 hours/ns, 39.805 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    | 24.601     | 24.601     | 24.601     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097237   | 0.097237   | 0.097237   |   0.0 |  0.39
Output  | 0.00020495 | 0.00020495 | 0.00020495 |   0.0 |  0.00
Modify  | 0.36236    | 0.36236    | 0.36236    |   0.0 |  1.44
Other   |            | 0.06183    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.807567984995, Press = 2.52204807878822
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17652.784   -17652.784   -17732.626   -17732.626    308.99583    308.99583    31318.952    31318.952   -399.14442   -399.14442 
   15000   -17647.317   -17647.317   -17731.418   -17731.418    325.47989    325.47989    31334.711    31334.711    -967.6302    -967.6302 
Loop time of 25.5104 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.387 ns/day, 7.086 hours/ns, 39.200 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    | 24.98      | 24.98      | 24.98      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097838   | 0.097838   | 0.097838   |   0.0 |  0.38
Output  | 0.00038472 | 0.00038472 | 0.00038472 |   0.0 |  0.00
Modify  | 0.37036    | 0.37036    | 0.37036    |   0.0 |  1.45
Other   |            | 0.062      |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.930686989342, Press = 2.21084824076379
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17647.317   -17647.317   -17731.418   -17731.418    325.47989    325.47989    31334.711    31334.711    -967.6302    -967.6302 
   16000   -17652.705   -17652.705   -17733.717   -17733.717    313.52267    313.52267    31350.393    31350.393   -5478.7777   -5478.7777 
Loop time of 25.1815 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.431 ns/day, 6.995 hours/ns, 39.712 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    | 24.656     | 24.656     | 24.656     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096925   | 0.096925   | 0.096925   |   0.0 |  0.38
Output  | 0.00015148 | 0.00015148 | 0.00015148 |   0.0 |  0.00
Modify  | 0.36643    | 0.36643    | 0.36643    |   0.0 |  1.46
Other   |            | 0.06198    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.901271716109, Press = 1.65609052564676
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17652.705   -17652.705   -17733.717   -17733.717    313.52267    313.52267    31350.393    31350.393   -5478.7777   -5478.7777 
   17000   -17653.319   -17653.319   -17731.947   -17731.947    304.29684    304.29684    31309.752    31309.752    215.82113    215.82113 
Loop time of 25.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.453 ns/day, 6.950 hours/ns, 39.970 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    | 24.499     | 24.499     | 24.499     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096676   | 0.096676   | 0.096676   |   0.0 |  0.39
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.36097    | 0.36097    | 0.36097    |   0.0 |  1.44
Other   |            | 0.06177    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.82936355969, Press = 0.407656684235544
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17653.319   -17653.319   -17731.947   -17731.947    304.29684    304.29684    31309.752    31309.752    215.82113    215.82113 
   18000   -17650.228   -17650.228   -17734.717   -17734.717    326.98347    326.98347    31300.815    31300.815    1023.6578    1023.6578 
Loop time of 24.9633 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.461 ns/day, 6.934 hours/ns, 40.059 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    | 24.444     | 24.444     | 24.444     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096985   | 0.096985   | 0.096985   |   0.0 |  0.39
Output  | 0.00015669 | 0.00015669 | 0.00015669 |   0.0 |  0.00
Modify  | 0.36029    | 0.36029    | 0.36029    |   0.0 |  1.44
Other   |            | 0.06165    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.689521907409, Press = -2.31638445794272
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17650.228   -17650.228   -17734.717   -17734.717    326.98347    326.98347    31300.815    31300.815    1023.6578    1023.6578 
   19000   -17650.707   -17650.707   -17733.611   -17733.611    320.84733    320.84733    31307.391    31307.391     1733.633     1733.633 
Loop time of 25.3816 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.404 ns/day, 7.050 hours/ns, 39.399 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    | 24.856     | 24.856     | 24.856     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097663   | 0.097663   | 0.097663   |   0.0 |  0.38
Output  | 0.0001567  | 0.0001567  | 0.0001567  |   0.0 |  0.00
Modify  | 0.36648    | 0.36648    | 0.36648    |   0.0 |  1.44
Other   |            | 0.06157    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.612198836237, Press = 0.0901150327974208
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17650.707   -17650.707   -17733.611   -17733.611    320.84733    320.84733    31307.391    31307.391     1733.633     1733.633 
   20000   -17652.563   -17652.563   -17732.346   -17732.346    308.76986    308.76986    31299.122    31299.122     1977.952     1977.952 
Loop time of 25.0634 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.962 hours/ns, 39.899 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    | 24.54      | 24.54      | 24.54      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097726   | 0.097726   | 0.097726   |   0.0 |  0.39
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.36362    | 0.36362    | 0.36362    |   0.0 |  1.45
Other   |            | 0.06168    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.714874273277, Press = -0.333009761621388
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17652.563   -17652.563   -17732.346   -17732.346    308.76986    308.76986    31299.122    31299.122     1977.952     1977.952 
   21000   -17648.344   -17648.344    -17730.76    -17730.76    318.95872    318.95872    31320.465    31320.465    628.05193    628.05193 
Loop time of 25.0942 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.971 hours/ns, 39.850 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    | 24.573     | 24.573     | 24.573     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096367   | 0.096367   | 0.096367   |   0.0 |  0.38
Output  | 0.00015782 | 0.00015782 | 0.00015782 |   0.0 |  0.00
Modify  | 0.36314    | 0.36314    | 0.36314    |   0.0 |  1.45
Other   |            | 0.06183    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.734350825056, Press = 2.09704831416128
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17648.344   -17648.344    -17730.76    -17730.76    318.95872    318.95872    31320.465    31320.465    628.05193    628.05193 
   22000   -17653.126   -17653.126     -17734.4     -17734.4    314.53944    314.53944    31329.965    31329.965   -2321.4497   -2321.4497 
Loop time of 25.518 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.386 ns/day, 7.088 hours/ns, 39.188 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    | 24.99      | 24.99      | 24.99      |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098197   | 0.098197   | 0.098197   |   0.0 |  0.38
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.36741    | 0.36741    | 0.36741    |   0.0 |  1.44
Other   |            | 0.06223    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 314.736796253414, Press = -2.39207405812074
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17653.126   -17653.126     -17734.4     -17734.4    314.53944    314.53944    31329.965    31329.965   -2321.4497   -2321.4497 
   23000   -17654.074   -17654.074   -17733.206   -17733.206    306.25078    306.25078    31297.842    31297.842    2070.1661    2070.1661 
Loop time of 25.3393 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.410 ns/day, 7.039 hours/ns, 39.464 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    | 24.81      | 24.81      | 24.81      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098701   | 0.098701   | 0.098701   |   0.0 |  0.39
Output  | 0.00015563 | 0.00015563 | 0.00015563 |   0.0 |  0.00
Modify  | 0.36791    | 0.36791    | 0.36791    |   0.0 |  1.45
Other   |            | 0.06212    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.741031392165, Press = -4.22597661580687
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17654.074   -17654.074   -17733.206   -17733.206    306.25078    306.25078    31297.842    31297.842    2070.1661    2070.1661 
   24000   -17649.847   -17649.847   -17730.448   -17730.448    311.93354    311.93354    31324.434    31324.434   -558.74644   -558.74644 
Loop time of 25.1173 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.977 hours/ns, 39.813 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    | 24.594     | 24.594     | 24.594     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096152   | 0.096152   | 0.096152   |   0.0 |  0.38
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.36588    | 0.36588    | 0.36588    |   0.0 |  1.46
Other   |            | 0.0616     |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.584138471226, Press = -3.42341850427167
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17649.847   -17649.847   -17730.448   -17730.448    311.93354    311.93354    31324.434    31324.434   -558.74644   -558.74644 
   25000   -17653.243   -17653.243   -17734.037   -17734.037    312.68074    312.68074    31271.685    31271.685    5856.0177    5856.0177 
Loop time of 25.2118 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.003 hours/ns, 39.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.689     | 24.689     | 24.689     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097239   | 0.097239   | 0.097239   |   0.0 |  0.39
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.36427    | 0.36427    | 0.36427    |   0.0 |  1.44
Other   |            | 0.06137    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.575505464953, Press = -1.56392025831393
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17653.243   -17653.243   -17734.037   -17734.037    312.68074    312.68074    31271.685    31271.685    5856.0177    5856.0177 
   26000   -17654.876   -17654.876   -17734.837   -17734.837    309.45618    309.45618    31278.119    31278.119     3636.799     3636.799 
Loop time of 25.823 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.346 ns/day, 7.173 hours/ns, 38.725 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    | 25.281     | 25.281     | 25.281     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10033    | 0.10033    | 0.10033    |   0.0 |  0.39
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.37913    | 0.37913    | 0.37913    |   0.0 |  1.47
Other   |            | 0.06241    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.452253908674, Press = 2.5184620570473
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17654.876   -17654.876   -17734.837   -17734.837    309.45618    309.45618    31278.119    31278.119     3636.799     3636.799 
   27000   -17649.059   -17649.059   -17731.788   -17731.788    320.16645    320.16645    31318.148    31318.148    788.30487    788.30487 
Loop time of 25.6932 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.363 ns/day, 7.137 hours/ns, 38.921 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    | 25.157     | 25.157     | 25.157     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098693   | 0.098693   | 0.098693   |   0.0 |  0.38
Output  | 0.00019372 | 0.00019372 | 0.00019372 |   0.0 |  0.00
Modify  | 0.37519    | 0.37519    | 0.37519    |   0.0 |  1.46
Other   |            | 0.06227    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 314.342743370188, Press = 1.51445706952886
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17649.059   -17649.059   -17731.788   -17731.788    320.16645    320.16645    31318.148    31318.148    788.30487    788.30487 
   28000   -17650.088   -17650.088   -17731.932   -17731.932    316.74385    316.74385    31316.984    31316.984    254.35926    254.35926 
Loop time of 25.3234 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.412 ns/day, 7.034 hours/ns, 39.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    | 24.792     | 24.792     | 24.792     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099073   | 0.099073   | 0.099073   |   0.0 |  0.39
Output  | 0.00015262 | 0.00015262 | 0.00015262 |   0.0 |  0.00
Modify  | 0.36994    | 0.36994    | 0.36994    |   0.0 |  1.46
Other   |            | 0.06234    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.264887099534, Press = -0.607019309274592
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17650.088   -17650.088   -17731.932   -17731.932    316.74385    316.74385    31316.984    31316.984    254.35926    254.35926 
   29000    -17649.91    -17649.91   -17730.736   -17730.736     312.8069     312.8069    31293.208    31293.208     4341.097     4341.097 
Loop time of 25.6159 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.373 ns/day, 7.116 hours/ns, 39.038 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    | 25.081     | 25.081     | 25.081     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099449   | 0.099449   | 0.099449   |   0.0 |  0.39
Output  | 0.0001522  | 0.0001522  | 0.0001522  |   0.0 |  0.00
Modify  | 0.373      | 0.373      | 0.373      |   0.0 |  1.46
Other   |            | 0.06198    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.264051597677, Press = 0.295642487000831
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -17649.91    -17649.91   -17730.736   -17730.736     312.8069     312.8069    31293.208    31293.208     4341.097     4341.097 
   30000   -17649.568   -17649.568   -17731.977   -17731.977    318.93185    318.93185    31331.908    31331.908   -1571.9516   -1571.9516 
Loop time of 25.5375 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.383 ns/day, 7.094 hours/ns, 39.158 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    | 25.005     | 25.005     | 25.005     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099019   | 0.099019   | 0.099019   |   0.0 |  0.39
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.37155    | 0.37155    | 0.37155    |   0.0 |  1.45
Other   |            | 0.06195    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.194798757931, Press = -1.79181431502657
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17649.568   -17649.568   -17731.977   -17731.977    318.93185    318.93185    31331.908    31331.908   -1571.9516   -1571.9516 
   31000   -17655.649   -17655.649   -17735.127   -17735.127    307.58889    307.58889    31296.851    31296.851    1724.1361    1724.1361 
Loop time of 25.0822 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.445 ns/day, 6.967 hours/ns, 39.869 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    | 24.562     | 24.562     | 24.562     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097112   | 0.097112   | 0.097112   |   0.0 |  0.39
Output  | 0.00018243 | 0.00018243 | 0.00018243 |   0.0 |  0.00
Modify  | 0.36103    | 0.36103    | 0.36103    |   0.0 |  1.44
Other   |            | 0.0616     |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.100112790707, Press = 0.989893936617282
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17655.649   -17655.649   -17735.127   -17735.127    307.58889    307.58889    31296.851    31296.851    1724.1361    1724.1361 
   32000   -17653.074   -17653.074   -17732.838   -17732.838    308.69226    308.69226    31285.455    31285.455    3935.1097    3935.1097 
Loop time of 25.2134 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.004 hours/ns, 39.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    | 24.69      | 24.69      | 24.69      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097606   | 0.097606   | 0.097606   |   0.0 |  0.39
Output  | 0.00015608 | 0.00015608 | 0.00015608 |   0.0 |  0.00
Modify  | 0.36411    | 0.36411    | 0.36411    |   0.0 |  1.44
Other   |            | 0.06191    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.023445445405, Press = -0.25933853671346
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17653.074   -17653.074   -17732.838   -17732.838    308.69226    308.69226    31285.455    31285.455    3935.1097    3935.1097 
   33000   -17645.605   -17645.605   -17728.884   -17728.884    322.29906    322.29906    31326.169    31326.169    383.75639    383.75639 
Loop time of 25.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.402 ns/day, 7.055 hours/ns, 39.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    | 24.871     | 24.871     | 24.871     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098739   | 0.098739   | 0.098739   |   0.0 |  0.39
Output  | 0.00015438 | 0.00015438 | 0.00015438 |   0.0 |  0.00
Modify  | 0.36583    | 0.36583    | 0.36583    |   0.0 |  1.44
Other   |            | 0.06175    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.06012424162, Press = 1.08529654796825
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17645.605   -17645.605   -17728.884   -17728.884    322.29906    322.29906    31326.169    31326.169    383.75639    383.75639 
   34000   -17652.457   -17652.457   -17732.156   -17732.156    308.44332    308.44332    31335.337    31335.337   -1375.3888   -1375.3888 
Loop time of 25.0944 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.971 hours/ns, 39.850 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.573     | 24.573     | 24.573     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096747   | 0.096747   | 0.096747   |   0.0 |  0.39
Output  | 0.00016013 | 0.00016013 | 0.00016013 |   0.0 |  0.00
Modify  | 0.36256    | 0.36256    | 0.36256    |   0.0 |  1.44
Other   |            | 0.06182    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.099638955588, Press = -0.683473378913236
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17652.457   -17652.457   -17732.156   -17732.156    308.44332    308.44332    31335.337    31335.337   -1375.3888   -1375.3888 
   35000   -17650.691   -17650.691    -17733.63    -17733.63    320.98547    320.98547    31310.484    31310.484    1009.8932    1009.8932 
Loop time of 25.9082 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.335 ns/day, 7.197 hours/ns, 38.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    | 25.368     | 25.368     | 25.368     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10027    | 0.10027    | 0.10027    |   0.0 |  0.39
Output  | 0.00019599 | 0.00019599 | 0.00019599 |   0.0 |  0.00
Modify  | 0.37675    | 0.37675    | 0.37675    |   0.0 |  1.45
Other   |            | 0.06267    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.983283273186, Press = 0.529968413243139
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17650.691   -17650.691    -17733.63    -17733.63    320.98547    320.98547    31310.484    31310.484    1009.8932    1009.8932 
   36000   -17652.637   -17652.637   -17732.825   -17732.825    310.33573    310.33573    31300.769    31300.769    2118.1755    2118.1755 
Loop time of 24.8359 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.479 ns/day, 6.899 hours/ns, 40.264 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    | 24.32      | 24.32      | 24.32      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096229   | 0.096229   | 0.096229   |   0.0 |  0.39
Output  | 0.00015269 | 0.00015269 | 0.00015269 |   0.0 |  0.00
Modify  | 0.358      | 0.358      | 0.358      |   0.0 |  1.44
Other   |            | 0.06174    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.977433534767, Press = 0.648011881536986
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17652.637   -17652.637   -17732.825   -17732.825    310.33573    310.33573    31300.769    31300.769    2118.1755    2118.1755 
   37000   -17652.485   -17652.485   -17734.397   -17734.397    317.00714    317.00714    31325.893    31325.893   -1246.8121   -1246.8121 
Loop time of 25.0269 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.952 hours/ns, 39.957 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    | 24.507     | 24.507     | 24.507     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09648    | 0.09648    | 0.09648    |   0.0 |  0.39
Output  | 0.00015862 | 0.00015862 | 0.00015862 |   0.0 |  0.00
Modify  | 0.36197    | 0.36197    | 0.36197    |   0.0 |  1.45
Other   |            | 0.06163    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.051608944843, Press = -1.09149117907914
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17652.485   -17652.485   -17734.397   -17734.397    317.00714    317.00714    31325.893    31325.893   -1246.8121   -1246.8121 
   38000   -17650.868   -17650.868     -17732.5     -17732.5    315.92369    315.92369     31305.66     31305.66    670.35749    670.35749 
Loop time of 25.3213 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.412 ns/day, 7.034 hours/ns, 39.492 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.795     | 24.795     | 24.795     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097587   | 0.097587   | 0.097587   |   0.0 |  0.39
Output  | 0.00015286 | 0.00015286 | 0.00015286 |   0.0 |  0.00
Modify  | 0.36719    | 0.36719    | 0.36719    |   0.0 |  1.45
Other   |            | 0.06152    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 314.00154474911, Press = 1.41189761877313
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17650.868   -17650.868     -17732.5     -17732.5    315.92369    315.92369     31305.66     31305.66    670.35749    670.35749 
   39000    -17652.08    -17652.08   -17732.718   -17732.718    312.07955    312.07955    31325.002    31325.002   -1062.5994   -1062.5994 
Loop time of 26.2936 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.286 ns/day, 7.304 hours/ns, 38.032 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    | 25.754     | 25.754     | 25.754     |   0.0 | 97.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099986   | 0.099986   | 0.099986   |   0.0 |  0.38
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.37704    | 0.37704    | 0.37704    |   0.0 |  1.43
Other   |            | 0.06267    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.896656194006, Press = 0.181562162896903
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -17652.08    -17652.08   -17732.718   -17732.718    312.07955    312.07955    31325.002    31325.002   -1062.5994   -1062.5994 
   40000   -17653.536   -17653.536   -17732.296   -17732.296    304.80842    304.80842    31339.264    31339.264    -3246.232    -3246.232 
Loop time of 25.2067 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.428 ns/day, 7.002 hours/ns, 39.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    | 24.684     | 24.684     | 24.684     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096829   | 0.096829   | 0.096829   |   0.0 |  0.38
Output  | 0.00015074 | 0.00015074 | 0.00015074 |   0.0 |  0.00
Modify  | 0.36349    | 0.36349    | 0.36349    |   0.0 |  1.44
Other   |            | 0.06178    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.881301686159, Press = -0.397792931161472
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17653.536   -17653.536   -17732.296   -17732.296    304.80842    304.80842    31339.264    31339.264    -3246.232    -3246.232 
   41000   -17650.194   -17650.194   -17730.092   -17730.092    309.21311    309.21311    31350.687    31350.687   -3902.1947   -3902.1947 
Loop time of 25.4153 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.400 ns/day, 7.060 hours/ns, 39.346 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    | 24.886     | 24.886     | 24.886     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097862   | 0.097862   | 0.097862   |   0.0 |  0.39
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.36944    | 0.36944    | 0.36944    |   0.0 |  1.45
Other   |            | 0.06144    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224012.0 ave      224012 max      224012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224012
Ave neighs/atom = 112.00600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.857629228354, Press = -3.75499186842216
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17650.194   -17650.194   -17730.092   -17730.092    309.21311    309.21311    31350.687    31350.687   -3902.1947   -3902.1947 
   42000   -17651.148   -17651.148   -17732.992   -17732.992    316.74555    316.74555    31295.727    31295.727    3297.0562    3297.0562 
Loop time of 25.3404 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.410 ns/day, 7.039 hours/ns, 39.463 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    | 24.811     | 24.811     | 24.811     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098068   | 0.098068   | 0.098068   |   0.0 |  0.39
Output  | 0.00015267 | 0.00015267 | 0.00015267 |   0.0 |  0.00
Modify  | 0.36913    | 0.36913    | 0.36913    |   0.0 |  1.46
Other   |            | 0.06217    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.814932076482, Press = -0.75365538346959
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17651.148   -17651.148   -17732.992   -17732.992    316.74555    316.74555    31295.727    31295.727    3297.0562    3297.0562 
   43000   -17652.067   -17652.067   -17733.924   -17733.924    316.79331    316.79331    31304.607    31304.607     1202.778     1202.778 
Loop time of 25.0492 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.449 ns/day, 6.958 hours/ns, 39.922 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    | 24.527     | 24.527     | 24.527     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097387   | 0.097387   | 0.097387   |   0.0 |  0.39
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.36344    | 0.36344    | 0.36344    |   0.0 |  1.45
Other   |            | 0.06152    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.81471088967, Press = -0.015403784650263
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17652.067   -17652.067   -17733.924   -17733.924    316.79331    316.79331    31304.607    31304.607     1202.778     1202.778 
   44000   -17652.856   -17652.856    -17734.35    -17734.35    315.38931    315.38931    31342.768    31342.768   -3866.6615   -3866.6615 
Loop time of 25.9963 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.324 ns/day, 7.221 hours/ns, 38.467 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    | 25.454     | 25.454     | 25.454     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10084    | 0.10084    | 0.10084    |   0.0 |  0.39
Output  | 0.00015687 | 0.00015687 | 0.00015687 |   0.0 |  0.00
Modify  | 0.3794     | 0.3794     | 0.3794     |   0.0 |  1.46
Other   |            | 0.06215    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.883766586973, Press = -0.961026788400842
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17652.856   -17652.856    -17734.35    -17734.35    315.38931    315.38931    31342.768    31342.768   -3866.6615   -3866.6615 
   45000   -17648.864   -17648.864   -17731.502   -17731.502    319.81778    319.81778    31360.249    31360.249   -5481.6601   -5481.6601 
Loop time of 25.1195 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.978 hours/ns, 39.810 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    | 24.595     | 24.595     | 24.595     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097035   | 0.097035   | 0.097035   |   0.0 |  0.39
Output  | 0.00015195 | 0.00015195 | 0.00015195 |   0.0 |  0.00
Modify  | 0.3651     | 0.3651     | 0.3651     |   0.0 |  1.45
Other   |            | 0.06232    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.887926794595, Press = -1.65276077300794
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17648.864   -17648.864   -17731.502   -17731.502    319.81778    319.81778    31360.249    31360.249   -5481.6601   -5481.6601 
   46000   -17653.079   -17653.079   -17733.943   -17733.943    312.95218    312.95218    31338.017    31338.017   -3259.5291   -3259.5291 
Loop time of 25.1365 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.437 ns/day, 6.982 hours/ns, 39.783 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    | 24.613     | 24.613     | 24.613     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097289   | 0.097289   | 0.097289   |   0.0 |  0.39
Output  | 0.0001589  | 0.0001589  | 0.0001589  |   0.0 |  0.00
Modify  | 0.36367    | 0.36367    | 0.36367    |   0.0 |  1.45
Other   |            | 0.06191    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.921532942918, Press = -0.132353846130111
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17653.079   -17653.079   -17733.943   -17733.943    312.95218    312.95218    31338.017    31338.017   -3259.5291   -3259.5291 
   47000   -17650.969   -17650.969   -17732.254   -17732.254    314.57977    314.57977    31350.799    31350.799   -4667.2363   -4667.2363 
Loop time of 25.2137 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.427 ns/day, 7.004 hours/ns, 39.661 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    | 24.689     | 24.689     | 24.689     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097966   | 0.097966   | 0.097966   |   0.0 |  0.39
Output  | 0.00019355 | 0.00019355 | 0.00019355 |   0.0 |  0.00
Modify  | 0.36507    | 0.36507    | 0.36507    |   0.0 |  1.45
Other   |            | 0.06193    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.899125224385, Press = 0.426283746473336
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17650.969   -17650.969   -17732.254   -17732.254    314.57977    314.57977    31350.799    31350.799   -4667.2363   -4667.2363 
   48000   -17652.117   -17652.117   -17732.858   -17732.858    312.47542    312.47542    31341.248    31341.248   -3378.0477   -3378.0477 
Loop time of 25.3939 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.402 ns/day, 7.054 hours/ns, 39.380 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.865     | 24.865     | 24.865     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099249   | 0.099249   | 0.099249   |   0.0 |  0.39
Output  | 0.00015778 | 0.00015778 | 0.00015778 |   0.0 |  0.00
Modify  | 0.36755    | 0.36755    | 0.36755    |   0.0 |  1.45
Other   |            | 0.06219    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.847175789041, Press = 1.08951667595035
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17652.117   -17652.117   -17732.858   -17732.858    312.47542    312.47542    31341.248    31341.248   -3378.0477   -3378.0477 
   49000   -17655.314   -17655.314   -17735.844   -17735.844    311.65981    311.65981    31300.246    31300.246    1035.1943    1035.1943 
Loop time of 25.0701 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.446 ns/day, 6.964 hours/ns, 39.888 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    | 24.548     | 24.548     | 24.548     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097034   | 0.097034   | 0.097034   |   0.0 |  0.39
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.36304    | 0.36304    | 0.36304    |   0.0 |  1.45
Other   |            | 0.06188    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.810675031321, Press = -0.167581607672197
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17655.314   -17655.314   -17735.844   -17735.844    311.65981    311.65981    31300.246    31300.246    1035.1943    1035.1943 
   50000   -17650.894   -17650.894   -17732.916   -17732.916     317.4344     317.4344     31289.34     31289.34    2888.5696    2888.5696 
Loop time of 25.0129 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.454 ns/day, 6.948 hours/ns, 39.979 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    | 24.489     | 24.489     | 24.489     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098559   | 0.098559   | 0.098559   |   0.0 |  0.39
Output  | 0.0001934  | 0.0001934  | 0.0001934  |   0.0 |  0.00
Modify  | 0.36429    | 0.36429    | 0.36429    |   0.0 |  1.46
Other   |            | 0.06111    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.730280922611, Press = 0.401388689502067
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17650.894   -17650.894   -17732.916   -17732.916     317.4344     317.4344     31289.34     31289.34    2888.5696    2888.5696 
   51000    -17652.42    -17652.42   -17732.643   -17732.643    310.46906    310.46906     31357.55     31357.55   -5682.2708   -5682.2708 
Loop time of 25.2961 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.416 ns/day, 7.027 hours/ns, 39.532 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.772     | 24.772     | 24.772     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097283   | 0.097283   | 0.097283   |   0.0 |  0.38
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.36461    | 0.36461    | 0.36461    |   0.0 |  1.44
Other   |            | 0.06194    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.711003618798, Press = 0.795461741814974
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -17652.42    -17652.42   -17732.643   -17732.643    310.46906    310.46906     31357.55     31357.55   -5682.2708   -5682.2708 
   52000   -17649.808   -17649.808   -17730.133   -17730.133    310.86443    310.86443    31343.825    31343.825   -1886.0718   -1886.0718 
Loop time of 25.204 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.428 ns/day, 7.001 hours/ns, 39.676 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    | 24.681     | 24.681     | 24.681     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098179   | 0.098179   | 0.098179   |   0.0 |  0.39
Output  | 0.00015195 | 0.00015195 | 0.00015195 |   0.0 |  0.00
Modify  | 0.36341    | 0.36341    | 0.36341    |   0.0 |  1.44
Other   |            | 0.06171    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.715380962643, Press = 0.116218444850993
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17649.808   -17649.808   -17730.133   -17730.133    310.86443    310.86443    31343.825    31343.825   -1886.0718   -1886.0718 
   53000    -17652.31    -17652.31   -17733.122   -17733.122      312.749      312.749    31305.205    31305.205    1203.3665    1203.3665 
Loop time of 25.2716 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.419 ns/day, 7.020 hours/ns, 39.570 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    | 24.745     | 24.745     | 24.745     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097898   | 0.097898   | 0.097898   |   0.0 |  0.39
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.36675    | 0.36675    | 0.36675    |   0.0 |  1.45
Other   |            | 0.06212    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.713841186018, Press = -0.448704391111285
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -17652.31    -17652.31   -17733.122   -17733.122      312.749      312.749    31305.205    31305.205    1203.3665    1203.3665 
   54000   -17652.407   -17652.407   -17734.511   -17734.511    317.75312    317.75312    31311.556    31311.556    734.13191    734.13191 
Loop time of 25.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.441 ns/day, 6.975 hours/ns, 39.825 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.588     | 24.588     | 24.588     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096928   | 0.096928   | 0.096928   |   0.0 |  0.39
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.3633     | 0.3633     | 0.3633     |   0.0 |  1.45
Other   |            | 0.06183    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.751894633322, Press = 0.403228755607797
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17652.407   -17652.407   -17734.511   -17734.511    317.75312    317.75312    31311.556    31311.556    734.13191    734.13191 
   55000   -17649.639   -17649.639   -17731.601   -17731.601    317.20388    317.20388    31335.333    31335.333   -2447.3826   -2447.3826 
Loop time of 25.2352 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.424 ns/day, 7.010 hours/ns, 39.627 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    | 24.714     | 24.714     | 24.714     |   0.0 | 97.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096942   | 0.096942   | 0.096942   |   0.0 |  0.38
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.36287    | 0.36287    | 0.36287    |   0.0 |  1.44
Other   |            | 0.06125    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.76943828847, Press = -0.424782033119177
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17649.639   -17649.639   -17731.601   -17731.601    317.20388    317.20388    31335.333    31335.333   -2447.3826   -2447.3826 
   56000   -17650.986   -17650.986   -17733.132   -17733.132    317.91375    317.91375    31354.317    31354.317   -4399.7225   -4399.7225 
Loop time of 25.5006 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.388 ns/day, 7.084 hours/ns, 39.215 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    | 24.971     | 24.971     | 24.971     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098883   | 0.098883   | 0.098883   |   0.0 |  0.39
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.36847    | 0.36847    | 0.36847    |   0.0 |  1.44
Other   |            | 0.06196    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.727159647385, Press = -0.125254382636403
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17650.986   -17650.986   -17733.132   -17733.132    317.91375    317.91375    31354.317    31354.317   -4399.7225   -4399.7225 
   57000   -17653.609   -17653.609   -17735.176   -17735.176    315.67441    315.67441    31296.861    31296.861    1748.7592    1748.7592 
Loop time of 25.0327 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.451 ns/day, 6.954 hours/ns, 39.948 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    | 24.511     | 24.511     | 24.511     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097108   | 0.097108   | 0.097108   |   0.0 |  0.39
Output  | 0.00015806 | 0.00015806 | 0.00015806 |   0.0 |  0.00
Modify  | 0.36245    | 0.36245    | 0.36245    |   0.0 |  1.45
Other   |            | 0.06192    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.685413450486, Press = -0.69936883085426
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17653.609   -17653.609   -17735.176   -17735.176    315.67441    315.67441    31296.861    31296.861    1748.7592    1748.7592 
   58000   -17650.859   -17650.859   -17733.634   -17733.634     320.3472     320.3472    31330.389    31330.389   -2193.6641   -2193.6641 
Loop time of 25.4156 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.399 ns/day, 7.060 hours/ns, 39.346 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    | 24.886     | 24.886     | 24.886     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097813   | 0.097813   | 0.097813   |   0.0 |  0.38
Output  | 0.00015047 | 0.00015047 | 0.00015047 |   0.0 |  0.00
Modify  | 0.36926    | 0.36926    | 0.36926    |   0.0 |  1.45
Other   |            | 0.06202    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.622595516177, Press = -0.516887464747248
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17650.859   -17650.859   -17733.634   -17733.634     320.3472     320.3472    31330.389    31330.389   -2193.6641   -2193.6641 
   59000   -17650.188   -17650.188   -17733.362   -17733.362    321.89339    321.89339    31362.785    31362.785   -6833.2777   -6833.2777 
Loop time of 25.8504 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.342 ns/day, 7.181 hours/ns, 38.684 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    | 25.312     | 25.312     | 25.312     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099007   | 0.099007   | 0.099007   |   0.0 |  0.38
Output  | 0.00015327 | 0.00015327 | 0.00015327 |   0.0 |  0.00
Modify  | 0.37659    | 0.37659    | 0.37659    |   0.0 |  1.46
Other   |            | 0.06294    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.606731161787, Press = -0.131350765108333
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17650.188   -17650.188   -17733.362   -17733.362    321.89339    321.89339    31362.785    31362.785   -6833.2777   -6833.2777 
   60000   -17652.705   -17652.705   -17733.752   -17733.752    313.66071    313.66071    31302.443    31302.443     1424.528     1424.528 
Loop time of 25.4558 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.394 ns/day, 7.071 hours/ns, 39.284 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    | 24.922     | 24.922     | 24.922     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099112   | 0.099112   | 0.099112   |   0.0 |  0.39
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.37217    | 0.37217    | 0.37217    |   0.0 |  1.46
Other   |            | 0.06259    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.647191413467, Press = -0.415060896255946
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17652.705   -17652.705   -17733.752   -17733.752    313.66071    313.66071    31302.443    31302.443     1424.528     1424.528 
   61000     -17647.5     -17647.5   -17730.682   -17730.682    321.92209    321.92209    31352.891    31352.891    -4022.304    -4022.304 
Loop time of 25.5402 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.383 ns/day, 7.095 hours/ns, 39.154 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    | 25.007     | 25.007     | 25.007     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099907   | 0.099907   | 0.099907   |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.37077    | 0.37077    | 0.37077    |   0.0 |  1.45
Other   |            | 0.0624     |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.686147009434, Press = 0.108341231191753
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000     -17647.5     -17647.5   -17730.682   -17730.682    321.92209    321.92209    31352.891    31352.891    -4022.304    -4022.304 
   62000   -17650.475   -17650.475   -17731.808   -17731.808    314.76979    314.76979    31336.334    31336.334   -2473.7354   -2473.7354 
Loop time of 25.1705 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.433 ns/day, 6.992 hours/ns, 39.729 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    | 24.647     | 24.647     | 24.647     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097771   | 0.097771   | 0.097771   |   0.0 |  0.39
Output  | 0.00015662 | 0.00015662 | 0.00015662 |   0.0 |  0.00
Modify  | 0.36398    | 0.36398    | 0.36398    |   0.0 |  1.45
Other   |            | 0.06153    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.675856785099, Press = 0.347275111999944
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17650.475   -17650.475   -17731.808   -17731.808    314.76979    314.76979    31336.334    31336.334   -2473.7354   -2473.7354 
   63000   -17654.079   -17654.079   -17735.008   -17735.008    313.20358    313.20358    31300.788    31300.788    1789.9187    1789.9187 
Loop time of 25.3825 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.404 ns/day, 7.051 hours/ns, 39.397 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    | 24.853     | 24.853     | 24.853     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098376   | 0.098376   | 0.098376   |   0.0 |  0.39
Output  | 0.00015234 | 0.00015234 | 0.00015234 |   0.0 |  0.00
Modify  | 0.36887    | 0.36887    | 0.36887    |   0.0 |  1.45
Other   |            | 0.06206    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.614991656718, Press = -0.378872203613277
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17654.079   -17654.079   -17735.008   -17735.008    313.20358    313.20358    31300.788    31300.788    1789.9187    1789.9187 
   64000   -17650.903   -17650.903   -17732.515   -17732.515    315.84718    315.84718    31319.768    31319.768    25.408585    25.408585 
Loop time of 24.8601 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.475 ns/day, 6.906 hours/ns, 40.225 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.341     | 24.341     | 24.341     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096371   | 0.096371   | 0.096371   |   0.0 |  0.39
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.36057    | 0.36057    | 0.36057    |   0.0 |  1.45
Other   |            | 0.06158    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.615485177032, Press = 0.906121642625722
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17650.903   -17650.903   -17732.515   -17732.515    315.84718    315.84718    31319.768    31319.768    25.408585    25.408585 
   65000   -17650.161   -17650.161   -17731.081   -17731.081    313.16948    313.16948    31319.732    31319.732    576.56445    576.56445 
Loop time of 25.3251 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.412 ns/day, 7.035 hours/ns, 39.486 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    | 24.798     | 24.798     | 24.798     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098442   | 0.098442   | 0.098442   |   0.0 |  0.39
Output  | 0.00016051 | 0.00016051 | 0.00016051 |   0.0 |  0.00
Modify  | 0.36712    | 0.36712    | 0.36712    |   0.0 |  1.45
Other   |            | 0.06161    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.627727871335, Press = 0.143260397034141
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17650.161   -17650.161   -17731.081   -17731.081    313.16948    313.16948    31319.732    31319.732    576.56445    576.56445 
   66000   -17652.534   -17652.534   -17732.903   -17732.903    311.03719    311.03719    31326.336    31326.336   -1572.4554   -1572.4554 
Loop time of 25.1893 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.430 ns/day, 6.997 hours/ns, 39.699 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    | 24.663     | 24.663     | 24.663     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097144   | 0.097144   | 0.097144   |   0.0 |  0.39
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.36639    | 0.36639    | 0.36639    |   0.0 |  1.45
Other   |            | 0.06223    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.67931709882, Press = -1.05259874822717
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -17652.534   -17652.534   -17732.903   -17732.903    311.03719    311.03719    31326.336    31326.336   -1572.4554   -1572.4554 
   67000   -17651.988   -17651.988   -17734.209   -17734.209    318.20459    318.20459     31308.08     31308.08   -293.11401   -293.11401 
Loop time of 25.3584 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.407 ns/day, 7.044 hours/ns, 39.435 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    | 24.831     | 24.831     | 24.831     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097487   | 0.097487   | 0.097487   |   0.0 |  0.38
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.36758    | 0.36758    | 0.36758    |   0.0 |  1.45
Other   |            | 0.06218    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.669167605921, Press = -0.817641449956559
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -17651.988   -17651.988   -17734.209   -17734.209    318.20459    318.20459     31308.08     31308.08   -293.11401   -293.11401 
   68000    -17652.15    -17652.15   -17732.623   -17732.623    311.43755    311.43755    31276.549    31276.549    5031.9876    5031.9876 
Loop time of 26.1419 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.305 ns/day, 7.262 hours/ns, 38.253 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.598     | 25.598     | 25.598     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10064    | 0.10064    | 0.10064    |   0.0 |  0.38
Output  | 0.00015629 | 0.00015629 | 0.00015629 |   0.0 |  0.00
Modify  | 0.3805     | 0.3805     | 0.3805     |   0.0 |  1.46
Other   |            | 0.06223    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.603415967875, Press = 0.0650313707427668
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000    -17652.15    -17652.15   -17732.623   -17732.623    311.43755    311.43755    31276.549    31276.549    5031.9876    5031.9876 
   69000   -17653.398   -17653.398   -17733.234   -17733.234    308.97223    308.97223    31308.046    31308.046    395.62014    395.62014 
Loop time of 25.2665 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.420 ns/day, 7.018 hours/ns, 39.578 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    | 24.74      | 24.74      | 24.74      |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09752    | 0.09752    | 0.09752    |   0.0 |  0.39
Output  | 0.00019914 | 0.00019914 | 0.00019914 |   0.0 |  0.00
Modify  | 0.36664    | 0.36664    | 0.36664    |   0.0 |  1.45
Other   |            | 0.0617     |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.596651601138, Press = 0.683407139372634
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -17653.398   -17653.398   -17733.234   -17733.234    308.97223    308.97223    31308.046    31308.046    395.62014    395.62014 
   70000   -17647.445   -17647.445   -17731.166   -17731.166    324.01082    324.01082    31305.357    31305.357    1756.9311    1756.9311 
Loop time of 25.0561 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.448 ns/day, 6.960 hours/ns, 39.910 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    | 24.534     | 24.534     | 24.534     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096557   | 0.096557   | 0.096557   |   0.0 |  0.39
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.36349    | 0.36349    | 0.36349    |   0.0 |  1.45
Other   |            | 0.06188    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.621020457316, Press = -1.25843756984233
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -17647.445   -17647.445   -17731.166   -17731.166    324.01082    324.01082    31305.357    31305.357    1756.9311    1756.9311 
   71000   -17651.185   -17651.185   -17733.587   -17733.587    318.90207    318.90207    31312.513    31312.513   -149.39072   -149.39072 
Loop time of 25.1278 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.438 ns/day, 6.980 hours/ns, 39.797 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    | 24.604     | 24.604     | 24.604     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097296   | 0.097296   | 0.097296   |   0.0 |  0.39
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.36469    | 0.36469    | 0.36469    |   0.0 |  1.45
Other   |            | 0.062      |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.630654694709, Press = -0.721130705492825
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -17651.185   -17651.185   -17733.587   -17733.587    318.90207    318.90207    31312.513    31312.513   -149.39072   -149.39072 
   72000   -17654.447   -17654.447   -17731.874   -17731.874    299.65241    299.65241    31288.588    31288.588    4148.8125    4148.8125 
Loop time of 25.0548 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.448 ns/day, 6.960 hours/ns, 39.912 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    | 24.531     | 24.531     | 24.531     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097653   | 0.097653   | 0.097653   |   0.0 |  0.39
Output  | 0.00015288 | 0.00015288 | 0.00015288 |   0.0 |  0.00
Modify  | 0.36338    | 0.36338    | 0.36338    |   0.0 |  1.45
Other   |            | 0.06225    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.663533050738, Press = -0.436585878127658
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -17654.447   -17654.447   -17731.874   -17731.874    299.65241    299.65241    31288.588    31288.588    4148.8125    4148.8125 
   73000   -17651.019   -17651.019   -17730.747   -17730.747    308.55518    308.55518    31311.931    31311.931    1242.4253    1242.4253 
Loop time of 25.5558 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.381 ns/day, 7.099 hours/ns, 39.130 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    | 25.023     | 25.023     | 25.023     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099243   | 0.099243   | 0.099243   |   0.0 |  0.39
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.37111    | 0.37111    | 0.37111    |   0.0 |  1.45
Other   |            | 0.06216    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.654746379295, Press = 0.484485979951062
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -17651.019   -17651.019   -17730.747   -17730.747    308.55518    308.55518    31311.931    31311.931    1242.4253    1242.4253 
   74000   -17651.219   -17651.219    -17730.58    -17730.58    307.13492    307.13492     31338.27     31338.27   -2236.4509   -2236.4509 
Loop time of 25.5691 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.379 ns/day, 7.103 hours/ns, 39.110 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 25.034     | 25.034     | 25.034     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098553   | 0.098553   | 0.098553   |   0.0 |  0.39
Output  | 0.00015652 | 0.00015652 | 0.00015652 |   0.0 |  0.00
Modify  | 0.37423    | 0.37423    | 0.37423    |   0.0 |  1.46
Other   |            | 0.062      |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.646328517441, Press = -1.05798586873507
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -17651.219   -17651.219    -17730.58    -17730.58    307.13492    307.13492     31338.27     31338.27   -2236.4509   -2236.4509 
   75000   -17652.059   -17652.059   -17732.616   -17732.616    311.76255    311.76255    31337.332    31337.332   -2871.2855   -2871.2855 
Loop time of 25.0316 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.452 ns/day, 6.953 hours/ns, 39.950 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    | 24.506     | 24.506     | 24.506     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098885   | 0.098885   | 0.098885   |   0.0 |  0.40
Output  | 0.00019819 | 0.00019819 | 0.00019819 |   0.0 |  0.00
Modify  | 0.36538    | 0.36538    | 0.36538    |   0.0 |  1.46
Other   |            | 0.06148    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.652451432973, Press = 0.0627531803723521
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -17652.059   -17652.059   -17732.616   -17732.616    311.76255    311.76255    31337.332    31337.332   -2871.2855   -2871.2855 
   76000    -17651.72    -17651.72   -17732.832   -17732.832    313.90902    313.90902    31314.318    31314.318    208.85206    208.85206 
Loop time of 25.4209 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.399 ns/day, 7.061 hours/ns, 39.338 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    | 24.891     | 24.891     | 24.891     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098561   | 0.098561   | 0.098561   |   0.0 |  0.39
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.36854    | 0.36854    | 0.36854    |   0.0 |  1.45
Other   |            | 0.06237    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.643594044914, Press = 0.124266954744909
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000    -17651.72    -17651.72   -17732.832   -17732.832    313.90902    313.90902    31314.318    31314.318    208.85206    208.85206 
   77000   -17656.992   -17656.992   -17734.437   -17734.437    299.72084    299.72084    31275.091    31275.091    4360.6751    4360.6751 
Loop time of 24.8829 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.472 ns/day, 6.912 hours/ns, 40.188 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    | 24.362     | 24.362     | 24.362     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097294   | 0.097294   | 0.097294   |   0.0 |  0.39
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36183    | 0.36183    | 0.36183    |   0.0 |  1.45
Other   |            | 0.06186    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.613958276988, Press = 0.899393654174681
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -17656.992   -17656.992   -17734.437   -17734.437    299.72084    299.72084    31275.091    31275.091    4360.6751    4360.6751 
   78000   -17651.702   -17651.702   -17731.232   -17731.232    307.78937    307.78937    31316.856    31316.856    593.07405    593.07405 
Loop time of 25.0599 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.448 ns/day, 6.961 hours/ns, 39.904 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    | 24.537     | 24.537     | 24.537     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097302   | 0.097302   | 0.097302   |   0.0 |  0.39
Output  | 0.00015936 | 0.00015936 | 0.00015936 |   0.0 |  0.00
Modify  | 0.36345    | 0.36345    | 0.36345    |   0.0 |  1.45
Other   |            | 0.06219    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.575614041659, Press = 0.180430011577637
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -17651.702   -17651.702   -17731.232   -17731.232    307.78937    307.78937    31316.856    31316.856    593.07405    593.07405 
   79000   -17653.026   -17653.026   -17734.592   -17734.592    315.66963    315.66963    31302.689    31302.689    1352.4983    1352.4983 
Loop time of 24.9529 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.463 ns/day, 6.931 hours/ns, 40.076 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    | 24.432     | 24.432     | 24.432     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097421   | 0.097421   | 0.097421   |   0.0 |  0.39
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.3608     | 0.3608     | 0.3608     |   0.0 |  1.45
Other   |            | 0.06225    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224012.0 ave      224012 max      224012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224012
Ave neighs/atom = 112.00600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.547293120771, Press = 0.192701890663932
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -17653.026   -17653.026   -17734.592   -17734.592    315.66963    315.66963    31302.689    31302.689    1352.4983    1352.4983 
   80000   -17650.697   -17650.697   -17732.749   -17732.749     317.5491     317.5491    31318.561    31318.561    292.38545    292.38545 
Loop time of 24.9921 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.457 ns/day, 6.942 hours/ns, 40.013 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    | 24.471     | 24.471     | 24.471     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097236   | 0.097236   | 0.097236   |   0.0 |  0.39
Output  | 0.00015688 | 0.00015688 | 0.00015688 |   0.0 |  0.00
Modify  | 0.36174    | 0.36174    | 0.36174    |   0.0 |  1.45
Other   |            | 0.06174    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.561757199263, Press = 0.421950326595775
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -17650.697   -17650.697   -17732.749   -17732.749     317.5491     317.5491    31318.561    31318.561    292.38545    292.38545 
   81000   -17652.019   -17652.019   -17734.208   -17734.208     318.0811     318.0811    31287.644    31287.644    2947.9399    2947.9399 
Loop time of 25.3874 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.403 ns/day, 7.052 hours/ns, 39.390 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    | 24.858     | 24.858     | 24.858     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098009   | 0.098009   | 0.098009   |   0.0 |  0.39
Output  | 0.00019301 | 0.00019301 | 0.00019301 |   0.0 |  0.00
Modify  | 0.36856    | 0.36856    | 0.36856    |   0.0 |  1.45
Other   |            | 0.06222    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.563430395876, Press = 0.248888269467248
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -17652.019   -17652.019   -17734.208   -17734.208     318.0811     318.0811    31287.644    31287.644    2947.9399    2947.9399 
   82000    -17652.07    -17652.07   -17733.829   -17733.829    316.41826    316.41826    31319.907    31319.907   -832.86138   -832.86138 
Loop time of 25.4286 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.398 ns/day, 7.063 hours/ns, 39.326 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    | 24.904     | 24.904     | 24.904     |   0.0 | 97.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097609   | 0.097609   | 0.097609   |   0.0 |  0.38
Output  | 0.00015197 | 0.00015197 | 0.00015197 |   0.0 |  0.00
Modify  | 0.3655     | 0.3655     | 0.3655     |   0.0 |  1.44
Other   |            | 0.06118    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.594986363152, Press = 0.398644665803698
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000    -17652.07    -17652.07   -17733.829   -17733.829    316.41826    316.41826    31319.907    31319.907   -832.86138   -832.86138 
   83000   -17650.099   -17650.099   -17730.655   -17730.655    311.76035    311.76035    31339.513    31339.513   -2036.2482   -2036.2482 
Loop time of 25.1147 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.440 ns/day, 6.976 hours/ns, 39.817 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    | 24.588     | 24.588     | 24.588     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098081   | 0.098081   | 0.098081   |   0.0 |  0.39
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.36597    | 0.36597    | 0.36597    |   0.0 |  1.46
Other   |            | 0.06223    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.585866420062, Press = -0.406918723391275
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -17650.099   -17650.099   -17730.655   -17730.655    311.76035    311.76035    31339.513    31339.513   -2036.2482   -2036.2482 
   84000   -17652.551   -17652.551   -17730.534   -17730.534    301.80316    301.80316    31352.785    31352.785    -4068.829    -4068.829 
Loop time of 25.2696 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.419 ns/day, 7.019 hours/ns, 39.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    | 24.744     | 24.744     | 24.744     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097959   | 0.097959   | 0.097959   |   0.0 |  0.39
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.36577    | 0.36577    | 0.36577    |   0.0 |  1.45
Other   |            | 0.06191    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.575093906539, Press = -0.146466385297153
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -17652.551   -17652.551   -17730.534   -17730.534    301.80316    301.80316    31352.785    31352.785    -4068.829    -4068.829 
   85000   -17653.454   -17653.454   -17733.507   -17733.507    309.81371    309.81371    31326.761    31326.761   -1376.2881   -1376.2881 
Loop time of 25.1686 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.433 ns/day, 6.991 hours/ns, 39.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    | 24.645     | 24.645     | 24.645     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098223   | 0.098223   | 0.098223   |   0.0 |  0.39
Output  | 0.00015295 | 0.00015295 | 0.00015295 |   0.0 |  0.00
Modify  | 0.36351    | 0.36351    | 0.36351    |   0.0 |  1.44
Other   |            | 0.06179    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.590639166658, Press = 0.470730094345544
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -17653.454   -17653.454   -17733.507   -17733.507    309.81371    309.81371    31326.761    31326.761   -1376.2881   -1376.2881 
   86000   -17650.466   -17650.466   -17729.707   -17729.707    306.67109    306.67109    31362.098    31362.098   -3904.1723   -3904.1723 
Loop time of 25.1562 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.435 ns/day, 6.988 hours/ns, 39.752 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.632     | 24.632     | 24.632     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097823   | 0.097823   | 0.097823   |   0.0 |  0.39
Output  | 0.00019624 | 0.00019624 | 0.00019624 |   0.0 |  0.00
Modify  | 0.36432    | 0.36432    | 0.36432    |   0.0 |  1.45
Other   |            | 0.06182    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.607452545247, Press = -0.0711525936164427
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -17650.466   -17650.466   -17729.707   -17729.707    306.67109    306.67109    31362.098    31362.098   -3904.1723   -3904.1723 
   87000   -17653.359   -17653.359   -17732.991   -17732.991    308.18282    308.18282    31338.594    31338.594   -2657.8609   -2657.8609 
Loop time of 25.0446 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.450 ns/day, 6.957 hours/ns, 39.929 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    | 24.523     | 24.523     | 24.523     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096936   | 0.096936   | 0.096936   |   0.0 |  0.39
Output  | 0.00014907 | 0.00014907 | 0.00014907 |   0.0 |  0.00
Modify  | 0.36291    | 0.36291    | 0.36291    |   0.0 |  1.45
Other   |            | 0.06207    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.594254529662, Press = -0.299097668423371
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -17653.359   -17653.359   -17732.991   -17732.991    308.18282    308.18282    31338.594    31338.594   -2657.8609   -2657.8609 
   88000   -17653.798   -17653.798   -17732.213   -17732.213     303.4756     303.4756    31333.281    31333.281   -1737.7761   -1737.7761 
Loop time of 25.023 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.453 ns/day, 6.951 hours/ns, 39.963 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    | 24.498     | 24.498     | 24.498     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09754    | 0.09754    | 0.09754    |   0.0 |  0.39
Output  | 0.000156   | 0.000156   | 0.000156   |   0.0 |  0.00
Modify  | 0.3642     | 0.3642     | 0.3642     |   0.0 |  1.46
Other   |            | 0.06309    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.568587811435, Press = 0.408562459777241
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -17653.798   -17653.798   -17732.213   -17732.213     303.4756     303.4756    31333.281    31333.281   -1737.7761   -1737.7761 
   89000   -17651.351   -17651.351   -17730.673   -17730.673    306.98287    306.98287    31361.042    31361.042   -4382.4863   -4382.4863 
Loop time of 25.0934 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.443 ns/day, 6.970 hours/ns, 39.851 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    | 24.569     | 24.569     | 24.569     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096747   | 0.096747   | 0.096747   |   0.0 |  0.39
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.36584    | 0.36584    | 0.36584    |   0.0 |  1.46
Other   |            | 0.06199    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.559577590336, Press = -0.487763769099173
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -17651.351   -17651.351   -17730.673   -17730.673    306.98287    306.98287    31361.042    31361.042   -4382.4863   -4382.4863 
   90000   -17651.498   -17651.498   -17732.408   -17732.408    313.12763    313.12763    31307.542    31307.542    2045.3941    2045.3941 
Loop time of 25.2695 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.419 ns/day, 7.019 hours/ns, 39.573 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    | 24.74      | 24.74      | 24.74      |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097965   | 0.097965   | 0.097965   |   0.0 |  0.39
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.36952    | 0.36952    | 0.36952    |   0.0 |  1.46
Other   |            | 0.06211    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.5148397157, Press = 0.195454329825107
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -17651.498   -17651.498   -17732.408   -17732.408    313.12763    313.12763    31307.542    31307.542    2045.3941    2045.3941 
   91000   -17655.724   -17655.724   -17735.846   -17735.846    310.07775    310.07775    31281.345    31281.345    3488.6171    3488.6171 
Loop time of 25.1479 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.436 ns/day, 6.986 hours/ns, 39.765 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    | 24.62      | 24.62      | 24.62      |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097948   | 0.097948   | 0.097948   |   0.0 |  0.39
Output  | 0.00016053 | 0.00016053 | 0.00016053 |   0.0 |  0.00
Modify  | 0.36795    | 0.36795    | 0.36795    |   0.0 |  1.46
Other   |            | 0.06142    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.497668547397, Press = -0.222272161052612
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -17655.724   -17655.724   -17735.846   -17735.846    310.07775    310.07775    31281.345    31281.345    3488.6171    3488.6171 
   92000   -17651.799   -17651.799   -17732.111   -17732.111    310.81232    310.81232    31298.746    31298.746    2984.4574    2984.4574 
Loop time of 25.3203 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.412 ns/day, 7.033 hours/ns, 39.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    | 24.791     | 24.791     | 24.791     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097845   | 0.097845   | 0.097845   |   0.0 |  0.39
Output  | 0.00015723 | 0.00015723 | 0.00015723 |   0.0 |  0.00
Modify  | 0.36865    | 0.36865    | 0.36865    |   0.0 |  1.46
Other   |            | 0.06279    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.485357953016, Press = 0.249242503977869
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -17651.799   -17651.799   -17732.111   -17732.111    310.81232    310.81232    31298.746    31298.746    2984.4574    2984.4574 
   93000    -17648.89    -17648.89   -17730.633   -17730.633    316.35366    316.35366    31343.675    31343.675   -2434.0885   -2434.0885 
Loop time of 25.0643 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.962 hours/ns, 39.897 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    | 24.543     | 24.543     | 24.543     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096729   | 0.096729   | 0.096729   |   0.0 |  0.39
Output  | 0.00019427 | 0.00019427 | 0.00019427 |   0.0 |  0.00
Modify  | 0.36198    | 0.36198    | 0.36198    |   0.0 |  1.44
Other   |            | 0.06223    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.49627262569, Press = -0.190960054231905
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000    -17648.89    -17648.89   -17730.633   -17730.633    316.35366    316.35366    31343.675    31343.675   -2434.0885   -2434.0885 
   94000   -17652.088   -17652.088   -17731.699   -17731.699    308.10426    308.10426    31298.872    31298.872    2944.4464    2944.4464 
Loop time of 25.4873 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.390 ns/day, 7.080 hours/ns, 39.235 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    | 24.954     | 24.954     | 24.954     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098697   | 0.098697   | 0.098697   |   0.0 |  0.39
Output  | 0.00019887 | 0.00019887 | 0.00019887 |   0.0 |  0.00
Modify  | 0.37152    | 0.37152    | 0.37152    |   0.0 |  1.46
Other   |            | 0.06241    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224004.0 ave      224004 max      224004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224004
Ave neighs/atom = 112.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 = 313.474425846374, Press = 0.0535699974370359
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -17652.088   -17652.088   -17731.699   -17731.699    308.10426    308.10426    31298.872    31298.872    2944.4464    2944.4464 
   95000   -17655.309   -17655.309   -17735.072   -17735.072    308.68908    308.68908    31285.945    31285.945    3065.0619    3065.0619 
Loop time of 24.8564 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.476 ns/day, 6.905 hours/ns, 40.231 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    | 24.338     | 24.338     | 24.338     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096291   | 0.096291   | 0.096291   |   0.0 |  0.39
Output  | 0.00015634 | 0.00015634 | 0.00015634 |   0.0 |  0.00
Modify  | 0.3604     | 0.3604     | 0.3604     |   0.0 |  1.45
Other   |            | 0.06203    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.453636058794, Press = -0.123565766698911
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -17655.309   -17655.309   -17735.072   -17735.072    308.68908    308.68908    31285.945    31285.945    3065.0619    3065.0619 
   96000   -17651.511   -17651.511   -17734.383   -17734.383    320.72444    320.72444     31313.68     31313.68   -46.258137   -46.258137 
Loop time of 25.0586 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.448 ns/day, 6.961 hours/ns, 39.906 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    | 24.538     | 24.538     | 24.538     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097014   | 0.097014   | 0.097014   |   0.0 |  0.39
Output  | 0.00020152 | 0.00020152 | 0.00020152 |   0.0 |  0.00
Modify  | 0.36211    | 0.36211    | 0.36211    |   0.0 |  1.45
Other   |            | 0.06134    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446613833096, Press = -0.105219393480396
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -17651.511   -17651.511   -17734.383   -17734.383    320.72444    320.72444     31313.68     31313.68   -46.258137   -46.258137 
   97000   -17652.157   -17652.157   -17733.416   -17733.416    314.48103    314.48103    31314.768    31314.768   -24.284181   -24.284181 
Loop time of 25.3503 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.408 ns/day, 7.042 hours/ns, 39.447 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    | 24.82      | 24.82      | 24.82      |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098264   | 0.098264   | 0.098264   |   0.0 |  0.39
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.36968    | 0.36968    | 0.36968    |   0.0 |  1.46
Other   |            | 0.06178    |            |       |  0.24

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.418958186699, Press = 0.320057578497813
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -17652.157   -17652.157   -17733.416   -17733.416    314.48103    314.48103    31314.768    31314.768   -24.284181   -24.284181 
   98000   -17652.049   -17652.049   -17732.357   -17732.357    310.79945    310.79945     31343.54     31343.54   -3336.6039   -3336.6039 
Loop time of 25.1259 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.439 ns/day, 6.979 hours/ns, 39.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    | 24.602     | 24.602     | 24.602     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098228   | 0.098228   | 0.098228   |   0.0 |  0.39
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.36394    | 0.36394    | 0.36394    |   0.0 |  1.45
Other   |            | 0.06177    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.426965813402, Press = 0.572189931051585
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -17652.049   -17652.049   -17732.357   -17732.357    310.79945    310.79945     31343.54     31343.54   -3336.6039   -3336.6039 
   99000   -17652.167   -17652.167   -17733.567   -17733.567    315.02972    315.02972     31302.03     31302.03    999.88299    999.88299 
Loop time of 25.4877 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.390 ns/day, 7.080 hours/ns, 39.235 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    | 24.956     | 24.956     | 24.956     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098685   | 0.098685   | 0.098685   |   0.0 |  0.39
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.37017    | 0.37017    | 0.37017    |   0.0 |  1.45
Other   |            | 0.06252    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.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 = 313.419951867637, Press = -0.429054492472809
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -17652.167   -17652.167   -17733.567   -17733.567    315.02972    315.02972     31302.03     31302.03    999.88299    999.88299 
  100000   -17652.663   -17652.663   -17733.779   -17733.779    313.92456    313.92456    31312.245    31312.245    238.59306    238.59306 
Loop time of 25.3184 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.413 ns/day, 7.033 hours/ns, 39.497 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    | 24.791     | 24.791     | 24.791     |   0.0 | 97.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097987   | 0.097987   | 0.097987   |   0.0 |  0.39
Output  | 0.00015235 | 0.00015235 | 0.00015235 |   0.0 |  0.00
Modify  | 0.36727    | 0.36727    | 0.36727    |   0.0 |  1.45
Other   |            | 0.06211    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.435263682765, Press = 0.34712604914981
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -17652.663   -17652.663   -17733.779   -17733.779    313.92456    313.92456    31312.245    31312.245    238.59306    238.59306 
  101000   -17654.542   -17654.542    -17734.27    -17734.27    308.55858    308.55858    31322.609    31322.609   -1356.2168   -1356.2168 
Loop time of 25.0111 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.454 ns/day, 6.948 hours/ns, 39.982 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    | 24.488     | 24.488     | 24.488     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097265   | 0.097265   | 0.097265   |   0.0 |  0.39
Output  | 0.00019199 | 0.00019199 | 0.00019199 |   0.0 |  0.00
Modify  | 0.3643     | 0.3643     | 0.3643     |   0.0 |  1.46
Other   |            | 0.06171    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224010.0 ave      224010 max      224010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224010
Ave neighs/atom = 112.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 = 313.432694996379, Press = -0.119405111690151
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -17654.542   -17654.542    -17734.27    -17734.27    308.55858    308.55858    31322.609    31322.609   -1356.2168   -1356.2168 
  102000   -17651.055   -17651.055   -17733.899   -17733.899    320.61288    320.61288    31326.483    31326.483   -1427.9731   -1427.9731 
Loop time of 25.2347 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.424 ns/day, 7.010 hours/ns, 39.628 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 24.707     | 24.707     | 24.707     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097738   | 0.097738   | 0.097738   |   0.0 |  0.39
Output  | 0.0001945  | 0.0001945  | 0.0001945  |   0.0 |  0.00
Modify  | 0.36716    | 0.36716    | 0.36716    |   0.0 |  1.45
Other   |            | 0.06223    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.403952542956, Press = 0.00187587832805005
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -17651.055   -17651.055   -17733.899   -17733.899    320.61288    320.61288    31326.483    31326.483   -1427.9731   -1427.9731 
  103000   -17654.418   -17654.418   -17732.791   -17732.791     303.3123     303.3123     31276.25     31276.25    5234.4684    5234.4684 
Loop time of 24.8275 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.480 ns/day, 6.897 hours/ns, 40.278 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    | 24.309     | 24.309     | 24.309     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095538   | 0.095538   | 0.095538   |   0.0 |  0.38
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.36039    | 0.36039    | 0.36039    |   0.0 |  1.45
Other   |            | 0.06244    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224002.0 ave      224002 max      224002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224002
Ave neighs/atom = 112.00100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.387877838359, Press = -0.520260350461479
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -17654.418   -17654.418   -17732.791   -17732.791     303.3123     303.3123     31276.25     31276.25    5234.4684    5234.4684 
  104000   -17653.429   -17653.429   -17734.582   -17734.582    314.07007    314.07007    31340.909    31340.909   -4094.4774   -4094.4774 
Loop time of 24.9562 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.462 ns/day, 6.932 hours/ns, 40.070 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    | 24.433     | 24.433     | 24.433     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096638   | 0.096638   | 0.096638   |   0.0 |  0.39
Output  | 0.00015905 | 0.00015905 | 0.00015905 |   0.0 |  0.00
Modify  | 0.36312    | 0.36312    | 0.36312    |   0.0 |  1.46
Other   |            | 0.06361    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224008
Ave neighs/atom = 112.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377041497275, Press = 0.468123668122448
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -17653.429   -17653.429   -17734.582   -17734.582    314.07007    314.07007    31340.909    31340.909   -4094.4774   -4094.4774 
  105000   -17655.058   -17655.058   -17733.222   -17733.222    302.50343    302.50343    31296.354    31296.354    2273.5438    2273.5438 
Loop time of 25.0691 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.446 ns/day, 6.964 hours/ns, 39.890 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    | 24.543     | 24.543     | 24.543     |   0.0 | 97.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096996   | 0.096996   | 0.096996   |   0.0 |  0.39
Output  | 0.00015049 | 0.00015049 | 0.00015049 |   0.0 |  0.00
Modify  | 0.36699    | 0.36699    | 0.36699    |   0.0 |  1.46
Other   |            | 0.06223    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224006.0 ave      224006 max      224006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224006
Ave neighs/atom = 112.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377329490882, Press = -0.309209411854612
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -17655.058   -17655.058   -17733.222   -17733.222    302.50343    302.50343    31296.354    31296.354    2273.5438    2273.5438 
  106000   -17650.874   -17650.874    -17730.48    -17730.48    308.08161    308.08161    31319.842    31319.842   -197.55553   -197.55553 
Loop time of 25.0655 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.447 ns/day, 6.963 hours/ns, 39.895 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    | 24.541     | 24.541     | 24.541     |   0.0 | 97.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097091   | 0.097091   | 0.097091   |   0.0 |  0.39
Output  | 0.00021089 | 0.00021089 | 0.00021089 |   0.0 |  0.00
Modify  | 0.36502    | 0.36502    | 0.36502    |   0.0 |  1.46
Other   |            | 0.06254    |            |       |  0.25

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224008.0 ave      224008 max      224008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0