# 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 2.867570169270039*${_u_distance}
variable latticeconst_converted equal 2.867570169270039*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86757016927004
Lattice spacing in x,y,z = 2.8675702 2.8675702 2.8675702
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 (28.675702 28.675702 28.675702)
  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 (28.675702 28.675702 28.675702)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_AslamBaskesDickel_2019_FeMnSiC__MO_427873955970_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23579.9110015415 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_427873955970_001#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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8479.084    -8479.084   -8559.9992   -8559.9992       313.15       313.15    23579.911    23579.911    3665.2824    3665.2824 
    1000    -8399.569    -8399.569    -8481.051    -8481.051    315.34388    315.34388    23771.026    23771.026    1774.9829    1774.9829 
Loop time of 198.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.434 ns/day, 55.247 hours/ns, 5.028 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    | 198.53     | 198.53     | 198.53     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058794   | 0.058794   | 0.058794   |   0.0 |  0.03
Output  | 0.00029216 | 0.00029216 | 0.00029216 |   0.0 |  0.00
Modify  | 0.26073    | 0.26073    | 0.26073    |   0.0 |  0.13
Other   |            | 0.04368    |            |       |  0.02

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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8399.569    -8399.569    -8481.051    -8481.051    315.34388    315.34388    23771.026    23771.026    1774.9829    1774.9829 
    2000   -8396.9215   -8396.9215   -8476.2674   -8476.2674    307.07691    307.07691    23802.357    23802.357   -5.9361261   -5.9361261 
Loop time of 149.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.650 hours/ns, 6.669 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.68     | 149.68     | 149.68     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041605   | 0.041605   | 0.041605   |   0.0 |  0.03
Output  | 0.00014345 | 0.00014345 | 0.00014345 |   0.0 |  0.00
Modify  | 0.18934    | 0.18934    | 0.18934    |   0.0 |  0.13
Other   |            | 0.031      |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239972.0 ave      239972 max      239972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239972
Ave neighs/atom = 119.98600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.9215   -8396.9215   -8476.2674   -8476.2674    307.07691    307.07691    23802.357    23802.357   -5.9361261   -5.9361261 
    3000   -8399.9414   -8399.9414   -8479.7077   -8479.7077    308.70396    308.70396    23814.147    23814.147   -1086.5483   -1086.5483 
Loop time of 149.793 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.609 hours/ns, 6.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    | 149.54     | 149.54     | 149.54     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040901   | 0.040901   | 0.040901   |   0.0 |  0.03
Output  | 0.00014842 | 0.00014842 | 0.00014842 |   0.0 |  0.00
Modify  | 0.18636    | 0.18636    | 0.18636    |   0.0 |  0.12
Other   |            | 0.02976    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239610.0 ave      239610 max      239610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239610
Ave neighs/atom = 119.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.9414   -8399.9414   -8479.7077   -8479.7077    308.70396    308.70396    23814.147    23814.147   -1086.5483   -1086.5483 
    4000   -8396.5333   -8396.5333   -8475.3177   -8475.3177    304.90376    304.90376    23819.129    23819.129   -907.09226   -907.09226 
Loop time of 143.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.601 ns/day, 39.949 hours/ns, 6.953 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    | 143.57     | 143.57     | 143.57     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039848   | 0.039848   | 0.039848   |   0.0 |  0.03
Output  | 0.0001492  | 0.0001492  | 0.0001492  |   0.0 |  0.00
Modify  | 0.1795     | 0.1795     | 0.1795     |   0.0 |  0.12
Other   |            | 0.0288     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239078.0 ave      239078 max      239078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239078
Ave neighs/atom = 119.53900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.5333   -8396.5333   -8475.3177   -8475.3177    304.90376    304.90376    23819.129    23819.129   -907.09226   -907.09226 
    5000   -8400.6079   -8400.6079   -8479.6873   -8479.6873    306.04558    306.04558    23781.794    23781.794    1129.5824    1129.5824 
Loop time of 142.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.605 ns/day, 39.648 hours/ns, 7.006 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    | 142.48     | 142.48     | 142.48     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039504   | 0.039504   | 0.039504   |   0.0 |  0.03
Output  | 0.00010501 | 0.00010501 | 0.00010501 |   0.0 |  0.00
Modify  | 0.17937    | 0.17937    | 0.17937    |   0.0 |  0.13
Other   |            | 0.02842    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239268.0 ave      239268 max      239268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239268
Ave neighs/atom = 119.63400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 308.865040874312, Press = 1252.1919486019
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.6079   -8400.6079   -8479.6873   -8479.6873    306.04558    306.04558    23781.794    23781.794    1129.5824    1129.5824 
    6000   -8398.5515   -8398.5515   -8478.8885   -8478.8885    310.91257    310.91257    23739.666    23739.666    4100.3074    4100.3074 
Loop time of 143.204 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.603 ns/day, 39.779 hours/ns, 6.983 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    | 142.95     | 142.95     | 142.95     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03972    | 0.03972    | 0.03972    |   0.0 |  0.03
Output  | 9.4912e-05 | 9.4912e-05 | 9.4912e-05 |   0.0 |  0.00
Modify  | 0.18773    | 0.18773    | 0.18773    |   0.0 |  0.13
Other   |            | 0.02897    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239522.0 ave      239522 max      239522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239522
Ave neighs/atom = 119.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.15881196882, Press = 79.8251618865949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.5515   -8398.5515   -8478.8885   -8478.8885    310.91257    310.91257    23739.666    23739.666    4100.3074    4100.3074 
    7000     -8398.02     -8398.02   -8478.5096   -8478.5096    311.50313    311.50313    23774.664    23774.664    1788.7299    1788.7299 
Loop time of 139.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.831 hours/ns, 7.154 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    | 139.54     | 139.54     | 139.54     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038794   | 0.038794   | 0.038794   |   0.0 |  0.03
Output  | 0.00010484 | 0.00010484 | 0.00010484 |   0.0 |  0.00
Modify  | 0.18134    | 0.18134    | 0.18134    |   0.0 |  0.13
Other   |            | 0.02832    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240514.0 ave      240514 max      240514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240514
Ave neighs/atom = 120.25700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.942774331003, Press = 1.52188349222151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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     -8398.02     -8398.02   -8478.5096   -8478.5096    311.50313    311.50313    23774.664    23774.664    1788.7299    1788.7299 
    8000   -8396.2373   -8396.2373   -8479.2739   -8479.2739    321.36021    321.36021    23804.413    23804.413   -184.98344   -184.98344 
Loop time of 153.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.561 ns/day, 42.747 hours/ns, 6.498 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.61     | 153.61     | 153.61     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043063   | 0.043063   | 0.043063   |   0.0 |  0.03
Output  | 0.00010993 | 0.00010993 | 0.00010993 |   0.0 |  0.00
Modify  | 0.20189    | 0.20189    | 0.20189    |   0.0 |  0.13
Other   |            | 0.031      |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239976.0 ave      239976 max      239976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239976
Ave neighs/atom = 119.98800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.903959009123, Press = 7.38745041157289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.2373   -8396.2373   -8479.2739   -8479.2739    321.36021    321.36021    23804.413    23804.413   -184.98344   -184.98344 
    9000   -8396.7695   -8396.7695   -8479.1568   -8479.1568     318.8474     318.8474    23816.285    23816.285   -992.79892   -992.79892 
Loop time of 179.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.481 ns/day, 49.934 hours/ns, 5.563 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    | 179.44     | 179.44     | 179.44     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050092   | 0.050092   | 0.050092   |   0.0 |  0.03
Output  | 0.00020478 | 0.00020478 | 0.00020478 |   0.0 |  0.00
Modify  | 0.23416    | 0.23416    | 0.23416    |   0.0 |  0.13
Other   |            | 0.03578    |            |       |  0.02

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:      239182.0 ave      239182 max      239182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239182
Ave neighs/atom = 119.59100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.889278030291, Press = 11.2549635023351
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.7695   -8396.7695   -8479.1568   -8479.1568     318.8474     318.8474    23816.285    23816.285   -992.79892   -992.79892 
   10000   -8396.0626   -8396.0626   -8477.7572   -8477.7572    316.16635    316.16635    23817.367    23817.367   -986.79694   -986.79694 
Loop time of 159.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.543 ns/day, 44.228 hours/ns, 6.281 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    | 158.94     | 158.94     | 158.94     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044334   | 0.044334   | 0.044334   |   0.0 |  0.03
Output  | 9.9056e-05 | 9.9056e-05 | 9.9056e-05 |   0.0 |  0.00
Modify  | 0.20808    | 0.20808    | 0.20808    |   0.0 |  0.13
Other   |            | 0.03257    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239222.0 ave      239222 max      239222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239222
Ave neighs/atom = 119.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.603213227074, Press = 13.4094899401293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.0626   -8396.0626   -8477.7572   -8477.7572    316.16635    316.16635    23817.367    23817.367   -986.79694   -986.79694 
   11000    -8398.886    -8398.886   -8480.2907   -8480.2907    315.04452    315.04452    23785.774    23785.774    859.29792    859.29792 
Loop time of 142.065 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.608 ns/day, 39.462 hours/ns, 7.039 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    | 141.81     | 141.81     | 141.81     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039717   | 0.039717   | 0.039717   |   0.0 |  0.03
Output  | 0.00010204 | 0.00010204 | 0.00010204 |   0.0 |  0.00
Modify  | 0.18718    | 0.18718    | 0.18718    |   0.0 |  0.13
Other   |            | 0.02978    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239308.0 ave      239308 max      239308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239308
Ave neighs/atom = 119.65400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.696996083103, Press = 18.217569879411
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8398.886    -8398.886   -8480.2907   -8480.2907    315.04452    315.04452    23785.774    23785.774    859.29792    859.29792 
   12000   -8395.4991   -8395.4991   -8477.4593   -8477.4593    317.19424    317.19424    23763.409    23763.409    2922.4915    2922.4915 
Loop time of 142.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.608 ns/day, 39.480 hours/ns, 7.036 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.87     | 141.87     | 141.87     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039782   | 0.039782   | 0.039782   |   0.0 |  0.03
Output  | 0.00010466 | 0.00010466 | 0.00010466 |   0.0 |  0.00
Modify  | 0.187      | 0.187      | 0.187      |   0.0 |  0.13
Other   |            | 0.02914    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239582.0 ave      239582 max      239582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239582
Ave neighs/atom = 119.79100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.688651534678, Press = 11.2494245115662
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.4991   -8395.4991   -8477.4593   -8477.4593    317.19424    317.19424    23763.409    23763.409    2922.4915    2922.4915 
   13000   -8400.6487   -8400.6487   -8480.3789   -8480.3789    308.56385    308.56385    23770.795    23770.795    1968.9369    1968.9369 
Loop time of 142.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.605 ns/day, 39.652 hours/ns, 7.005 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    | 142.49     | 142.49     | 142.49     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039542   | 0.039542   | 0.039542   |   0.0 |  0.03
Output  | 0.00010382 | 0.00010382 | 0.00010382 |   0.0 |  0.00
Modify  | 0.18733    | 0.18733    | 0.18733    |   0.0 |  0.13
Other   |            | 0.02892    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4124.00 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240084.0 ave      240084 max      240084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240084
Ave neighs/atom = 120.04200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.641709151343, Press = 1.33696163010672
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.6487   -8400.6487   -8480.3789   -8480.3789    308.56385    308.56385    23770.795    23770.795    1968.9369    1968.9369 
   14000   -8400.7723   -8400.7723    -8479.824    -8479.824     305.9384     305.9384    23802.075    23802.075    -204.2273    -204.2273 
Loop time of 144.156 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.599 ns/day, 40.043 hours/ns, 6.937 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    | 143.9      | 143.9      | 143.9      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040272   | 0.040272   | 0.040272   |   0.0 |  0.03
Output  | 0.00010867 | 0.00010867 | 0.00010867 |   0.0 |  0.00
Modify  | 0.18862    | 0.18862    | 0.18862    |   0.0 |  0.13
Other   |            | 0.02886    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239680.0 ave      239680 max      239680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239680
Ave neighs/atom = 119.84000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.435060419888, Press = -1.9972671575843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.7723   -8400.7723    -8479.824    -8479.824     305.9384     305.9384    23802.075    23802.075    -204.2273    -204.2273 
   15000   -8397.4732   -8397.4732   -8478.0069   -8478.0069    311.67361    311.67361    23823.889    23823.889   -1452.0478   -1452.0478 
Loop time of 142.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.617 hours/ns, 7.012 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    | 142.37     | 142.37     | 142.37     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039607   | 0.039607   | 0.039607   |   0.0 |  0.03
Output  | 0.00010617 | 0.00010617 | 0.00010617 |   0.0 |  0.00
Modify  | 0.1863     | 0.1863     | 0.1863     |   0.0 |  0.13
Other   |            | 0.02878    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239356.0 ave      239356 max      239356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239356
Ave neighs/atom = 119.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.057395924142, Press = 3.62854217769614
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.4732   -8397.4732   -8478.0069   -8478.0069    311.67361    311.67361    23823.889    23823.889   -1452.0478   -1452.0478 
   16000   -8399.5028   -8399.5028   -8481.8208   -8481.8208    318.57888    318.57888    23807.102    23807.102   -671.42683   -671.42683 
Loop time of 140.587 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.615 ns/day, 39.052 hours/ns, 7.113 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.33     | 140.33     | 140.33     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03942    | 0.03942    | 0.03942    |   0.0 |  0.03
Output  | 0.00010731 | 0.00010731 | 0.00010731 |   0.0 |  0.00
Modify  | 0.18434    | 0.18434    | 0.18434    |   0.0 |  0.13
Other   |            | 0.02882    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238976.0 ave      238976 max      238976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238976
Ave neighs/atom = 119.48800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.068194134779, Press = 5.51842683691882
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.5028   -8399.5028   -8481.8208   -8481.8208    318.57888    318.57888    23807.102    23807.102   -671.42683   -671.42683 
   17000   -8396.2415   -8396.2415   -8478.6854   -8478.6854    319.06622    319.06622    23803.608    23803.608   -31.716979   -31.716979 
Loop time of 141.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.182 hours/ns, 7.089 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    | 140.8      | 140.8      | 140.8      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039434   | 0.039434   | 0.039434   |   0.0 |  0.03
Output  | 0.00037204 | 0.00037204 | 0.00037204 |   0.0 |  0.00
Modify  | 0.18566    | 0.18566    | 0.18566    |   0.0 |  0.13
Other   |            | 0.0289     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239102.0 ave      239102 max      239102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239102
Ave neighs/atom = 119.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.211592648148, Press = 4.13814148553877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.2415   -8396.2415   -8478.6854   -8478.6854    319.06622    319.06622    23803.608    23803.608   -31.716979   -31.716979 
   18000   -8401.3855   -8401.3855   -8480.1349   -8480.1349     304.7684     304.7684    23793.092    23793.092    223.50405    223.50405 
Loop time of 234.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 65.108 hours/ns, 4.266 timesteps/s
98.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.98     | 233.98     | 233.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06495    | 0.06495    | 0.06495    |   0.0 |  0.03
Output  | 0.00033473 | 0.00033473 | 0.00033473 |   0.0 |  0.00
Modify  | 0.29581    | 0.29581    | 0.29581    |   0.0 |  0.13
Other   |            | 0.04632    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239374.0 ave      239374 max      239374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239374
Ave neighs/atom = 119.68700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.947442648625, Press = 2.62149678927953
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8401.3855   -8401.3855   -8480.1349   -8480.1349     304.7684     304.7684    23793.092    23793.092    223.50405    223.50405 
   19000   -8400.5585   -8400.5585    -8477.888    -8477.888    299.27302    299.27302    23820.962    23820.962   -1414.3235   -1414.3235 
Loop time of 166.023 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.118 hours/ns, 6.023 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    | 165.72     | 165.72     | 165.72     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04735    | 0.04735    | 0.04735    |   0.0 |  0.03
Output  | 9.2811e-05 | 9.2811e-05 | 9.2811e-05 |   0.0 |  0.00
Modify  | 0.21736    | 0.21736    | 0.21736    |   0.0 |  0.13
Other   |            | 0.03669    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4132.00 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239392.0 ave      239392 max      239392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239392
Ave neighs/atom = 119.69600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897021748284, Press = 2.69120150602595
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.5585   -8400.5585    -8477.888    -8477.888    299.27302    299.27302    23820.962    23820.962   -1414.3235   -1414.3235 
   20000   -8394.8186   -8394.8186   -8477.5876   -8477.5876    320.32452    320.32452    23832.551    23832.551   -1894.3635   -1894.3635 
Loop time of 154.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.558 ns/day, 42.991 hours/ns, 6.461 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.5      | 154.5      | 154.5      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042444   | 0.042444   | 0.042444   |   0.0 |  0.03
Output  | 0.00016869 | 0.00016869 | 0.00016869 |   0.0 |  0.00
Modify  | 0.19777    | 0.19777    | 0.19777    |   0.0 |  0.13
Other   |            | 0.03091    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239148.0 ave      239148 max      239148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239148
Ave neighs/atom = 119.57400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.962345440314, Press = 6.26750114650349
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8394.8186   -8394.8186   -8477.5876   -8477.5876    320.32452    320.32452    23832.551    23832.551   -1894.3635   -1894.3635 
   21000    -8398.996    -8398.996   -8481.1301   -8481.1301    317.86732    317.86732    23790.021    23790.021    563.51289    563.51289 
Loop time of 157.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.625 hours/ns, 6.367 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    | 156.77     | 156.77     | 156.77     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044187   | 0.044187   | 0.044187   |   0.0 |  0.03
Output  | 0.00010575 | 0.00010575 | 0.00010575 |   0.0 |  0.00
Modify  | 0.20696    | 0.20696    | 0.20696    |   0.0 |  0.13
Other   |            | 0.03279    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238926.0 ave      238926 max      238926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238926
Ave neighs/atom = 119.46300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.0426673214, Press = 7.66198996095798
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8398.996    -8398.996   -8481.1301   -8481.1301    317.86732    317.86732    23790.021    23790.021    563.51289    563.51289 
   22000   -8396.0929   -8396.0929   -8478.3441   -8478.3441     318.3206     318.3206    23766.118    23766.118    2505.8451    2505.8451 
Loop time of 165.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.522 ns/day, 45.958 hours/ns, 6.044 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165.15     | 165.15     | 165.15     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046278   | 0.046278   | 0.046278   |   0.0 |  0.03
Output  | 0.000164   | 0.000164   | 0.000164   |   0.0 |  0.00
Modify  | 0.21599    | 0.21599    | 0.21599    |   0.0 |  0.13
Other   |            | 0.03373    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239478.0 ave      239478 max      239478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239478
Ave neighs/atom = 119.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.156215939853, Press = 4.5051164040771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.0929   -8396.0929   -8478.3441   -8478.3441     318.3206     318.3206    23766.118    23766.118    2505.8451    2505.8451 
   23000    -8397.699    -8397.699   -8477.1912   -8477.1912    307.64301    307.64301    23781.747    23781.747    1479.0524    1479.0524 
Loop time of 157.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.547 ns/day, 43.856 hours/ns, 6.334 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.6      | 157.6      | 157.6      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044207   | 0.044207   | 0.044207   |   0.0 |  0.03
Output  | 0.0001207  | 0.0001207  | 0.0001207  |   0.0 |  0.00
Modify  | 0.20574    | 0.20574    | 0.20574    |   0.0 |  0.13
Other   |            | 0.03211    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240198.0 ave      240198 max      240198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240198
Ave neighs/atom = 120.09900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.117023535759, Press = 1.51635327554716
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8397.699    -8397.699   -8477.1912   -8477.1912    307.64301    307.64301    23781.747    23781.747    1479.0524    1479.0524 
   24000   -8398.3078   -8398.3078   -8479.9987   -8479.9987    316.15233    316.15233    23798.873    23798.873   -51.459555   -51.459555 
Loop time of 142.173 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.92     | 141.92     | 141.92     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03979    | 0.03979    | 0.03979    |   0.0 |  0.03
Output  | 0.00018796 | 0.00018796 | 0.00018796 |   0.0 |  0.00
Modify  | 0.18573    | 0.18573    | 0.18573    |   0.0 |  0.13
Other   |            | 0.02876    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4131.00 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239694.0 ave      239694 max      239694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239694
Ave neighs/atom = 119.84700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.23295089746, Press = 0.763453698416278
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.3078   -8398.3078   -8479.9987   -8479.9987    316.15233    316.15233    23798.873    23798.873   -51.459555   -51.459555 
   25000   -8395.0953   -8395.0953   -8476.5314   -8476.5314      315.166      315.166    23816.488    23816.488   -677.06394   -677.06394 
Loop time of 143.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.602 ns/day, 39.841 hours/ns, 6.972 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    | 143.17     | 143.17     | 143.17     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039907   | 0.039907   | 0.039907   |   0.0 |  0.03
Output  | 0.00011959 | 0.00011959 | 0.00011959 |   0.0 |  0.00
Modify  | 0.1875     | 0.1875     | 0.1875     |   0.0 |  0.13
Other   |            | 0.02866    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239354.0 ave      239354 max      239354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239354
Ave neighs/atom = 119.67700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.218609291926, Press = 1.80512640007744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.0953   -8395.0953   -8476.5314   -8476.5314      315.166      315.166    23816.488    23816.488   -677.06394   -677.06394 
   26000   -8398.5118   -8398.5118   -8477.7311   -8477.7311    306.58703    306.58703    23817.931    23817.931   -1137.7408   -1137.7408 
Loop time of 141.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.610 ns/day, 39.335 hours/ns, 7.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.35     | 141.35     | 141.35     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039457   | 0.039457   | 0.039457   |   0.0 |  0.03
Output  | 9.9473e-05 | 9.9473e-05 | 9.9473e-05 |   0.0 |  0.00
Modify  | 0.18484    | 0.18484    | 0.18484    |   0.0 |  0.13
Other   |            | 0.02929    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239208.0 ave      239208 max      239208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239208
Ave neighs/atom = 119.60400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.185593383836, Press = 2.5971374059014
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.5118   -8398.5118   -8477.7311   -8477.7311    306.58703    306.58703    23817.931    23817.931   -1137.7408   -1137.7408 
   27000   -8398.2388   -8398.2388   -8479.0728   -8479.0728    312.83568    312.83568    23808.648    23808.648   -592.65233   -592.65233 
Loop time of 140.628 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.614 ns/day, 39.063 hours/ns, 7.111 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    | 140.38     | 140.38     | 140.38     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03895    | 0.03895    | 0.03895    |   0.0 |  0.03
Output  | 0.00010261 | 0.00010261 | 0.00010261 |   0.0 |  0.00
Modify  | 0.18232    | 0.18232    | 0.18232    |   0.0 |  0.13
Other   |            | 0.02884    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4131.00 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239060.0 ave      239060 max      239060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239060
Ave neighs/atom = 119.53000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.155793444339, Press = 6.07152382938917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.2388   -8398.2388   -8479.0728   -8479.0728    312.83568    312.83568    23808.648    23808.648   -592.65233   -592.65233 
   28000   -8397.5179   -8397.5179   -8478.9516   -8478.9516    315.15676    315.15676    23768.358    23768.358     2411.067     2411.067 
Loop time of 140.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.915 hours/ns, 7.138 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    | 139.85     | 139.85     | 139.85     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038963   | 0.038963   | 0.038963   |   0.0 |  0.03
Output  | 0.00011223 | 0.00011223 | 0.00011223 |   0.0 |  0.00
Modify  | 0.18191    | 0.18191    | 0.18191    |   0.0 |  0.13
Other   |            | 0.02911    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239136.0 ave      239136 max      239136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239136
Ave neighs/atom = 119.56800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.106088721694, Press = 5.50755000208602
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.5179   -8397.5179   -8478.9516   -8478.9516    315.15676    315.15676    23768.358    23768.358     2411.067     2411.067 
   29000   -8400.7836   -8400.7836   -8480.6965   -8480.6965    309.27118    309.27118    23762.943    23762.943     2239.639     2239.639 
Loop time of 144.526 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.146 hours/ns, 6.919 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.27     | 144.27     | 144.27     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040148   | 0.040148   | 0.040148   |   0.0 |  0.03
Output  | 0.00010435 | 0.00010435 | 0.00010435 |   0.0 |  0.00
Modify  | 0.18879    | 0.18879    | 0.18879    |   0.0 |  0.13
Other   |            | 0.02975    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239924.0 ave      239924 max      239924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239924
Ave neighs/atom = 119.96200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.081348266194, Press = 1.96381931599991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.7836   -8400.7836   -8480.6965   -8480.6965    309.27118    309.27118    23762.943    23762.943     2239.639     2239.639 
   30000   -8396.3778   -8396.3778   -8479.9418   -8479.9418    323.40133    323.40133    23792.541    23792.541    492.69539    492.69539 
Loop time of 142.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.604 ns/day, 39.720 hours/ns, 6.993 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    | 142.74     | 142.74     | 142.74     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039782   | 0.039782   | 0.039782   |   0.0 |  0.03
Output  | 0.00014748 | 0.00014748 | 0.00014748 |   0.0 |  0.00
Modify  | 0.18702    | 0.18702    | 0.18702    |   0.0 |  0.13
Other   |            | 0.02925    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4124.00 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240210.0 ave      240210 max      240210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240210
Ave neighs/atom = 120.10500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.03526451973, Press = 0.602615040785106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.3778   -8396.3778   -8479.9418   -8479.9418    323.40133    323.40133    23792.541    23792.541    492.69539    492.69539 
   31000   -8398.4071   -8398.4071   -8478.6163   -8478.6163    310.41815    310.41815    23806.176    23806.176   -256.66438   -256.66438 
Loop time of 142.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.607 ns/day, 39.547 hours/ns, 7.024 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    | 142.12     | 142.12     | 142.12     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039512   | 0.039512   | 0.039512   |   0.0 |  0.03
Output  | 0.00011253 | 0.00011253 | 0.00011253 |   0.0 |  0.00
Modify  | 0.18573    | 0.18573    | 0.18573    |   0.0 |  0.13
Other   |            | 0.02916    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239694.0 ave      239694 max      239694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239694
Ave neighs/atom = 119.84700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013224036181, Press = 0.765139381151128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.4071   -8398.4071   -8478.6163   -8478.6163    310.41815    310.41815    23806.176    23806.176   -256.66438   -256.66438 
   32000   -8400.9796   -8400.9796    -8479.547    -8479.547    304.06407    304.06407    23817.524    23817.524   -1319.0031   -1319.0031 
Loop time of 143.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.600 ns/day, 39.974 hours/ns, 6.949 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    | 143.65     | 143.65     | 143.65     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039711   | 0.039711   | 0.039711   |   0.0 |  0.03
Output  | 0.0001062  | 0.0001062  | 0.0001062  |   0.0 |  0.00
Modify  | 0.18688    | 0.18688    | 0.18688    |   0.0 |  0.13
Other   |            | 0.02885    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239442.0 ave      239442 max      239442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239442
Ave neighs/atom = 119.72100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.983285563611, Press = 1.552517748523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.9796   -8400.9796    -8479.547    -8479.547    304.06407    304.06407    23817.524    23817.524   -1319.0031   -1319.0031 
   33000   -8397.5198   -8397.5198    -8480.196    -8480.196    319.96539    319.96539    23829.815    23829.815   -2066.1204   -2066.1204 
Loop time of 143.184 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.603 ns/day, 39.773 hours/ns, 6.984 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    | 142.93     | 142.93     | 142.93     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039227   | 0.039227   | 0.039227   |   0.0 |  0.03
Output  | 0.00010812 | 0.00010812 | 0.00010812 |   0.0 |  0.00
Modify  | 0.18612    | 0.18612    | 0.18612    |   0.0 |  0.13
Other   |            | 0.02871    |            |       |  0.02

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:      239120.0 ave      239120 max      239120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239120
Ave neighs/atom = 119.56000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.000629719167, Press = 3.95800883287911
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.5198   -8397.5198    -8480.196    -8480.196    319.96539    319.96539    23829.815    23829.815   -2066.1204   -2066.1204 
   34000   -8400.8849   -8400.8849   -8477.9248   -8477.9248    298.15208    298.15208    23781.711    23781.711    1191.1554    1191.1554 
Loop time of 157.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.674 hours/ns, 6.360 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    | 156.94     | 156.94     | 156.94     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043703   | 0.043703   | 0.043703   |   0.0 |  0.03
Output  | 0.00010556 | 0.00010556 | 0.00010556 |   0.0 |  0.00
Modify  | 0.20487    | 0.20487    | 0.20487    |   0.0 |  0.13
Other   |            | 0.03171    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238756.0 ave      238756 max      238756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238756
Ave neighs/atom = 119.37800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897707594364, Press = 4.86696499375225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.8849   -8400.8849   -8477.9248   -8477.9248    298.15208    298.15208    23781.711    23781.711    1191.1554    1191.1554 
   35000   -8399.1777   -8399.1777   -8479.1277   -8479.1277    309.41467    309.41467    23764.269    23764.269     2426.679     2426.679 
Loop time of 188.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.457 ns/day, 52.467 hours/ns, 5.294 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    | 188.55     | 188.55     | 188.55     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052634   | 0.052634   | 0.052634   |   0.0 |  0.03
Output  | 9.533e-05  | 9.533e-05  | 9.533e-05  |   0.0 |  0.00
Modify  | 0.24333    | 0.24333    | 0.24333    |   0.0 |  0.13
Other   |            | 0.03802    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239748.0 ave      239748 max      239748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239748
Ave neighs/atom = 119.87400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.851242250431, Press = 2.19836786401562
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.1777   -8399.1777   -8479.1277   -8479.1277    309.41467    309.41467    23764.269    23764.269     2426.679     2426.679 
   36000   -8395.7957   -8395.7957   -8477.8388   -8477.8388    317.51515    317.51515     23791.59     23791.59     982.4482     982.4482 
Loop time of 138.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.624 ns/day, 38.458 hours/ns, 7.223 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    | 138.2      | 138.2      | 138.2      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038609   | 0.038609   | 0.038609   |   0.0 |  0.03
Output  | 0.00018927 | 0.00018927 | 0.00018927 |   0.0 |  0.00
Modify  | 0.17727    | 0.17727    | 0.17727    |   0.0 |  0.13
Other   |            | 0.02918    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239890.0 ave      239890 max      239890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239890
Ave neighs/atom = 119.94500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.829497005788, Press = 0.823588799130031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.7957   -8395.7957   -8477.8388   -8477.8388    317.51515    317.51515     23791.59     23791.59     982.4482     982.4482 
   37000   -8400.8829   -8400.8829   -8479.9695   -8479.9695    306.07335    306.07335    23797.263    23797.263    51.258095    51.258095 
Loop time of 134.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.328 hours/ns, 7.442 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    | 134.14     | 134.14     | 134.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0375     | 0.0375     | 0.0375     |   0.0 |  0.03
Output  | 9.9288e-05 | 9.9288e-05 | 9.9288e-05 |   0.0 |  0.00
Modify  | 0.16976    | 0.16976    | 0.16976    |   0.0 |  0.13
Other   |            | 0.02849    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239498.0 ave      239498 max      239498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239498
Ave neighs/atom = 119.74900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.801981133839, Press = 0.982744418794286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.8829   -8400.8829   -8479.9695   -8479.9695    306.07335    306.07335    23797.263    23797.263    51.258095    51.258095 
   38000   -8395.8949   -8395.8949   -8480.8073   -8480.8073    328.61942    328.61942    23807.984    23807.984   -669.62241   -669.62241 
Loop time of 134.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.641 ns/day, 37.449 hours/ns, 7.418 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    | 134.58     | 134.58     | 134.58     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037493   | 0.037493   | 0.037493   |   0.0 |  0.03
Output  | 9.707e-05  | 9.707e-05  | 9.707e-05  |   0.0 |  0.00
Modify  | 0.17173    | 0.17173    | 0.17173    |   0.0 |  0.13
Other   |            | 0.02798    |            |       |  0.02

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:      239400.0 ave      239400 max      239400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239400
Ave neighs/atom = 119.70000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81263365652, Press = 1.22724443687215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.8949   -8395.8949   -8480.8073   -8480.8073    328.61942    328.61942    23807.984    23807.984   -669.62241   -669.62241 
   39000    -8399.889    -8399.889   -8481.1221   -8481.1221    314.38031    314.38031      23804.5      23804.5   -484.24454   -484.24454 
Loop time of 134.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.358 hours/ns, 7.436 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    | 134.25     | 134.25     | 134.25     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037417   | 0.037417   | 0.037417   |   0.0 |  0.03
Output  | 9.8857e-05 | 9.8857e-05 | 9.8857e-05 |   0.0 |  0.00
Modify  | 0.17114    | 0.17114    | 0.17114    |   0.0 |  0.13
Other   |            | 0.02798    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239204.0 ave      239204 max      239204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239204
Ave neighs/atom = 119.60200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858112330647, Press = 1.22295737815598
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8399.889    -8399.889   -8481.1221   -8481.1221    314.38031    314.38031      23804.5      23804.5   -484.24454   -484.24454 
   40000   -8399.1173   -8399.1173   -8480.8669   -8480.8669    316.37931    316.37931    23804.873    23804.873   -527.65704   -527.65704 
Loop time of 137.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.628 ns/day, 38.207 hours/ns, 7.270 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.31     | 137.31     | 137.31     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037753   | 0.037753   | 0.037753   |   0.0 |  0.03
Output  | 9.5519e-05 | 9.5519e-05 | 9.5519e-05 |   0.0 |  0.00
Modify  | 0.17425    | 0.17425    | 0.17425    |   0.0 |  0.13
Other   |            | 0.02833    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239116.0 ave      239116 max      239116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239116
Ave neighs/atom = 119.55800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.765211767952, Press = 1.5290254895122
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.1173   -8399.1173   -8480.8669   -8480.8669    316.37931    316.37931    23804.873    23804.873   -527.65704   -527.65704 
   41000   -8398.0061   -8398.0061   -8478.9183   -8478.9183    313.13862    313.13862    23801.476    23801.476   -13.504449   -13.504449 
Loop time of 134.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.290 hours/ns, 7.449 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    | 134.01     | 134.01     | 134.01     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037421   | 0.037421   | 0.037421   |   0.0 |  0.03
Output  | 8.963e-05  | 8.963e-05  | 8.963e-05  |   0.0 |  0.00
Modify  | 0.1694     | 0.1694     | 0.1694     |   0.0 |  0.13
Other   |            | 0.02787    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239256.0 ave      239256 max      239256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239256
Ave neighs/atom = 119.62800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.719618174438, Press = 2.19517112119535
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.0061   -8398.0061   -8478.9183   -8478.9183    313.13862    313.13862    23801.476    23801.476   -13.504449   -13.504449 
   42000   -8399.8608   -8399.8608   -8478.1955   -8478.1955    303.16337    303.16337    23775.322    23775.322    1786.4492    1786.4492 
Loop time of 136.487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.633 ns/day, 37.913 hours/ns, 7.327 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    | 136.25     | 136.25     | 136.25     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037628   | 0.037628   | 0.037628   |   0.0 |  0.03
Output  | 0.00010095 | 0.00010095 | 0.00010095 |   0.0 |  0.00
Modify  | 0.17288    | 0.17288    | 0.17288    |   0.0 |  0.13
Other   |            | 0.02825    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239194.0 ave      239194 max      239194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239194
Ave neighs/atom = 119.59700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.698812404156, Press = 1.68846443360172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.8608   -8399.8608   -8478.1955   -8478.1955    303.16337    303.16337    23775.322    23775.322    1786.4492    1786.4492 
   43000   -8403.3074   -8403.3074   -8480.2785   -8480.2785    297.88614    297.88614    23757.159    23757.159     2685.907     2685.907 
Loop time of 141.602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.610 ns/day, 39.334 hours/ns, 7.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.35     | 141.35     | 141.35     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038863   | 0.038863   | 0.038863   |   0.0 |  0.03
Output  | 9.9858e-05 | 9.9858e-05 | 9.9858e-05 |   0.0 |  0.00
Modify  | 0.18141    | 0.18141    | 0.18141    |   0.0 |  0.13
Other   |            | 0.02877    |            |       |  0.02

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:      239728.0 ave      239728 max      239728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239728
Ave neighs/atom = 119.86400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.558730391628, Press = 0.329396113406933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8403.3074   -8403.3074   -8480.2785   -8480.2785    297.88614    297.88614    23757.159    23757.159     2685.907     2685.907 
   44000   -8398.1721   -8398.1721   -8479.7054   -8479.7054    315.54244    315.54244    23793.797    23793.797    416.02562    416.02562 
Loop time of 138.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.624 ns/day, 38.455 hours/ns, 7.223 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    | 138.2      | 138.2      | 138.2      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038313   | 0.038313   | 0.038313   |   0.0 |  0.03
Output  | 9.942e-05  | 9.942e-05  | 9.942e-05  |   0.0 |  0.00
Modify  | 0.17631    | 0.17631    | 0.17631    |   0.0 |  0.13
Other   |            | 0.02882    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240190.0 ave      240190 max      240190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240190
Ave neighs/atom = 120.09500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511507561975, Press = -1.20607258943336
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.1721   -8398.1721   -8479.7054   -8479.7054    315.54244    315.54244    23793.797    23793.797    416.02562    416.02562 
   45000   -8399.1099   -8399.1099   -8478.9136   -8478.9136    308.84851    308.84851    23836.361    23836.361   -2484.1529   -2484.1529 
Loop time of 139.139 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.650 hours/ns, 7.187 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    | 138.9      | 138.9      | 138.9      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038244   | 0.038244   | 0.038244   |   0.0 |  0.03
Output  | 9.4906e-05 | 9.4906e-05 | 9.4906e-05 |   0.0 |  0.00
Modify  | 0.1768     | 0.1768     | 0.1768     |   0.0 |  0.13
Other   |            | 0.02843    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239494.0 ave      239494 max      239494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239494
Ave neighs/atom = 119.74700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.488308470276, Press = -1.1216661527695
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.1099   -8399.1099   -8478.9136   -8478.9136    308.84851    308.84851    23836.361    23836.361   -2484.1529   -2484.1529 
   46000    -8398.825    -8398.825   -8479.4904   -8479.4904     312.1834     312.1834    23841.185    23841.185   -2791.1767   -2791.1767 
Loop time of 137.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.628 ns/day, 38.190 hours/ns, 7.274 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.24     | 137.24     | 137.24     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038013   | 0.038013   | 0.038013   |   0.0 |  0.03
Output  | 9.2863e-05 | 9.2863e-05 | 9.2863e-05 |   0.0 |  0.00
Modify  | 0.17388    | 0.17388    | 0.17388    |   0.0 |  0.13
Other   |            | 0.02863    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239034.0 ave      239034 max      239034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239034
Ave neighs/atom = 119.51700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456755108448, Press = 0.910161158411216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8398.825    -8398.825   -8479.4904   -8479.4904     312.1834     312.1834    23841.185    23841.185   -2791.1767   -2791.1767 
   47000   -8394.7977   -8394.7977   -8477.5419   -8477.5419    320.22874    320.22874    23821.335    23821.335   -1080.4863   -1080.4863 
Loop time of 137.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.291 hours/ns, 7.254 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.6      | 137.6      | 137.6      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038191   | 0.038191   | 0.038191   |   0.0 |  0.03
Output  | 9.8201e-05 | 9.8201e-05 | 9.8201e-05 |   0.0 |  0.00
Modify  | 0.17573    | 0.17573    | 0.17573    |   0.0 |  0.13
Other   |            | 0.02867    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238632.0 ave      238632 max      238632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238632
Ave neighs/atom = 119.31600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4441371606, Press = 1.82929711703408
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8394.7977   -8394.7977   -8477.5419   -8477.5419    320.22874    320.22874    23821.335    23821.335   -1080.4863   -1080.4863 
   48000   -8399.2927   -8399.2927   -8479.8366   -8479.8366    311.71323    311.71323    23797.082    23797.082    65.770236    65.770236 
Loop time of 140.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.121 hours/ns, 7.101 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    | 140.59     | 140.59     | 140.59     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038761   | 0.038761   | 0.038761   |   0.0 |  0.03
Output  | 9.1825e-05 | 9.1825e-05 | 9.1825e-05 |   0.0 |  0.00
Modify  | 0.18067    | 0.18067    | 0.18067    |   0.0 |  0.13
Other   |            | 0.0287     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239044.0 ave      239044 max      239044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239044
Ave neighs/atom = 119.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483344617894, Press = 1.52847033161025
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.2927   -8399.2927   -8479.8366   -8479.8366    311.71323    311.71323    23797.082    23797.082    65.770236    65.770236 
   49000   -8392.5884   -8392.5884   -8476.4559   -8476.4559    324.57599    324.57599     23791.07     23791.07     1225.078     1225.078 
Loop time of 140.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.614 ns/day, 39.091 hours/ns, 7.106 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    | 140.48     | 140.48     | 140.48     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038725   | 0.038725   | 0.038725   |   0.0 |  0.03
Output  | 0.00010583 | 0.00010583 | 0.00010583 |   0.0 |  0.00
Modify  | 0.18016    | 0.18016    | 0.18016    |   0.0 |  0.13
Other   |            | 0.02892    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239522.0 ave      239522 max      239522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239522
Ave neighs/atom = 119.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.519956135244, Press = 1.33449042513341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8392.5884   -8392.5884   -8476.4559   -8476.4559    324.57599    324.57599     23791.07     23791.07     1225.078     1225.078 
   50000   -8399.1206   -8399.1206   -8479.9013   -8479.9013    312.62964    312.62964    23750.263    23750.263    3351.5666    3351.5666 
Loop time of 155.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.204 hours/ns, 6.429 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.26     | 155.26     | 155.26     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042313   | 0.042313   | 0.042313   |   0.0 |  0.03
Output  | 9.7809e-05 | 9.7809e-05 | 9.7809e-05 |   0.0 |  0.00
Modify  | 0.19876    | 0.19876    | 0.19876    |   0.0 |  0.13
Other   |            | 0.03091    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239596.0 ave      239596 max      239596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239596
Ave neighs/atom = 119.79800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.546552904965, Press = 0.0433888914131274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.1206   -8399.1206   -8479.9013   -8479.9013    312.62964    312.62964    23750.263    23750.263    3351.5666    3351.5666 
   51000   -8399.3811   -8399.3811   -8478.8033   -8478.8033    307.37197    307.37197    23797.105    23797.105     197.7825     197.7825 
Loop time of 154.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.558 ns/day, 43.048 hours/ns, 6.453 timesteps/s
98.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.7      | 154.7      | 154.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042243   | 0.042243   | 0.042243   |   0.0 |  0.03
Output  | 0.0001059  | 0.0001059  | 0.0001059  |   0.0 |  0.00
Modify  | 0.19504    | 0.19504    | 0.19504    |   0.0 |  0.13
Other   |            | 0.03057    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4137.00 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240366.0 ave      240366 max      240366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240366
Ave neighs/atom = 120.18300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.580608244487, Press = -1.68989985231064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.3811   -8399.3811   -8478.8033   -8478.8033    307.37197    307.37197    23797.105    23797.105     197.7825     197.7825 
   52000   -8396.5973   -8396.5973   -8478.2039   -8478.2039    315.82596    315.82596    23825.022    23825.022   -1467.6805   -1467.6805 
Loop time of 168.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.809 hours/ns, 5.934 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.21     | 168.21     | 168.21     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046631   | 0.046631   | 0.046631   |   0.0 |  0.03
Output  | 0.00018568 | 0.00018568 | 0.00018568 |   0.0 |  0.00
Modify  | 0.21631    | 0.21631    | 0.21631    |   0.0 |  0.13
Other   |            | 0.03337    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239408.0 ave      239408 max      239408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239408
Ave neighs/atom = 119.70400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.526313080349, Press = -0.0894392804451021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.5973   -8396.5973   -8478.2039   -8478.2039    315.82596    315.82596    23825.022    23825.022   -1467.6805   -1467.6805 
   53000   -8402.2579   -8402.2579   -8482.4907   -8482.4907    310.50951    310.50951    23823.272    23823.272   -2016.5243   -2016.5243 
Loop time of 205.067 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.421 ns/day, 56.963 hours/ns, 4.876 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    | 204.7      | 204.7      | 204.7      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057688   | 0.057688   | 0.057688   |   0.0 |  0.03
Output  | 0.00011474 | 0.00011474 | 0.00011474 |   0.0 |  0.00
Modify  | 0.2661     | 0.2661     | 0.2661     |   0.0 |  0.13
Other   |            | 0.0424     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239076.0 ave      239076 max      239076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239076
Ave neighs/atom = 119.53800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.491443420446, Press = 1.03375944003902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8402.2579   -8402.2579   -8482.4907   -8482.4907    310.50951    310.50951    23823.272    23823.272   -2016.5243   -2016.5243 
   54000   -8398.1847   -8398.1847   -8478.4899   -8478.4899    310.78936    310.78936    23818.814    23818.814    -1161.212    -1161.212 
Loop time of 197.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.752 hours/ns, 5.073 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    | 196.75     | 196.75     | 196.75     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057253   | 0.057253   | 0.057253   |   0.0 |  0.03
Output  | 0.00011053 | 0.00011053 | 0.00011053 |   0.0 |  0.00
Modify  | 0.26187    | 0.26187    | 0.26187    |   0.0 |  0.13
Other   |            | 0.04238    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238900.0 ave      238900 max      238900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238900
Ave neighs/atom = 119.45000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.442804744141, Press = 2.17970706978424
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.1847   -8398.1847   -8478.4899   -8478.4899    310.78936    310.78936    23818.814    23818.814    -1161.212    -1161.212 
   55000   -8398.5893   -8398.5893   -8478.2248   -8478.2248    308.19762    308.19762    23783.734    23783.734    1212.9118    1212.9118 
Loop time of 240.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.359 ns/day, 66.944 hours/ns, 4.149 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 240.57     | 240.57     | 240.57     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068538   | 0.068538   | 0.068538   |   0.0 |  0.03
Output  | 0.00017433 | 0.00017433 | 0.00017433 |   0.0 |  0.00
Modify  | 0.31032    | 0.31032    | 0.31032    |   0.0 |  0.13
Other   |            | 0.04853    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4131.00 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239174.0 ave      239174 max      239174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239174
Ave neighs/atom = 119.58700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.41393308579, Press = 2.534658547524
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.5893   -8398.5893   -8478.2248   -8478.2248    308.19762    308.19762    23783.734    23783.734    1212.9118    1212.9118 
   56000   -8399.0337   -8399.0337   -8478.7399   -8478.7399    308.47157    308.47157    23759.609    23759.609    2800.9297    2800.9297 
Loop time of 236.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.365 ns/day, 65.716 hours/ns, 4.227 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    | 236.16     | 236.16     | 236.16     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067076   | 0.067076   | 0.067076   |   0.0 |  0.03
Output  | 0.00024541 | 0.00024541 | 0.00024541 |   0.0 |  0.00
Modify  | 0.30367    | 0.30367    | 0.30367    |   0.0 |  0.13
Other   |            | 0.04604    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4124.00 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239812.0 ave      239812 max      239812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239812
Ave neighs/atom = 119.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.420595232941, Press = 1.14156906024177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.0337   -8399.0337   -8478.7399   -8478.7399    308.47157    308.47157    23759.609    23759.609    2800.9297    2800.9297 
   57000   -8397.3183   -8397.3183   -8478.4589   -8478.4589     314.0225     314.0225    23787.487    23787.487    1001.4105    1001.4105 
Loop time of 249.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.347 ns/day, 69.204 hours/ns, 4.014 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    | 248.7      | 248.7      | 248.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06991    | 0.06991    | 0.06991    |   0.0 |  0.03
Output  | 0.00084694 | 0.00084694 | 0.00084694 |   0.0 |  0.00
Modify  | 0.31309    | 0.31309    | 0.31309    |   0.0 |  0.13
Other   |            | 0.04844    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4137.00 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239918.0 ave      239918 max      239918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239918
Ave neighs/atom = 119.95900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397620501366, Press = 0.384873873304197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.3183   -8397.3183   -8478.4589   -8478.4589     314.0225     314.0225    23787.487    23787.487    1001.4105    1001.4105 
   58000   -8399.5019   -8399.5019   -8479.2663   -8479.2663    308.69659    308.69659    23804.663    23804.663   -392.36274   -392.36274 
Loop time of 221.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.390 ns/day, 61.578 hours/ns, 4.511 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.29     | 221.29     | 221.29     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062671   | 0.062671   | 0.062671   |   0.0 |  0.03
Output  | 0.00017304 | 0.00017304 | 0.00017304 |   0.0 |  0.00
Modify  | 0.28452    | 0.28452    | 0.28452    |   0.0 |  0.13
Other   |            | 0.04339    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239628.0 ave      239628 max      239628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239628
Ave neighs/atom = 119.81400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.437101182834, Press = 0.180802780327506
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.5019   -8399.5019   -8479.2663   -8479.2663    308.69659    308.69659    23804.663    23804.663   -392.36274   -392.36274 
   59000   -8394.2965   -8394.2965   -8477.2591   -8477.2591    321.07384    321.07384    23820.633    23820.633   -1014.1096   -1014.1096 
Loop time of 285.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.303 ns/day, 79.283 hours/ns, 3.504 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    | 284.93     | 284.93     | 284.93     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077763   | 0.077763   | 0.077763   |   0.0 |  0.03
Output  | 0.00033694 | 0.00033694 | 0.00033694 |   0.0 |  0.00
Modify  | 0.35637    | 0.35637    | 0.35637    |   0.0 |  0.12
Other   |            | 0.05075    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4120.00 ave        4120 max        4120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239324.0 ave      239324 max      239324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239324
Ave neighs/atom = 119.66200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468407379333, Press = 0.540071539909287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8394.2965   -8394.2965   -8477.2591   -8477.2591    321.07384    321.07384    23820.633    23820.633   -1014.1096   -1014.1096 
   60000   -8400.0955   -8400.0955     -8480.21     -8480.21    310.05117    310.05117    23823.865    23823.865   -1762.9454   -1762.9454 
Loop time of 188.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.457 ns/day, 52.482 hours/ns, 5.293 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    | 188.59     | 188.59     | 188.59     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054053   | 0.054053   | 0.054053   |   0.0 |  0.03
Output  | 0.00021355 | 0.00021355 | 0.00021355 |   0.0 |  0.00
Modify  | 0.24585    | 0.24585    | 0.24585    |   0.0 |  0.13
Other   |            | 0.04005    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239196.0 ave      239196 max      239196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239196
Ave neighs/atom = 119.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.480760287622, Press = 1.11544980455398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.0955   -8400.0955     -8480.21     -8480.21    310.05117    310.05117    23823.865    23823.865   -1762.9454   -1762.9454 
   61000    -8393.175    -8393.175   -8476.9688   -8476.9688    324.29069    324.29069    23819.422    23819.422   -800.33066   -800.33066 
Loop time of 259.772 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.159 hours/ns, 3.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    | 259.32     | 259.32     | 259.32     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072561   | 0.072561   | 0.072561   |   0.0 |  0.03
Output  | 0.00017044 | 0.00017044 | 0.00017044 |   0.0 |  0.00
Modify  | 0.32956    | 0.32956    | 0.32956    |   0.0 |  0.13
Other   |            | 0.04999    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238952.0 ave      238952 max      238952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238952
Ave neighs/atom = 119.47600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.518084537751, Press = 2.70899633722031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8393.175    -8393.175   -8476.9688   -8476.9688    324.29069    324.29069    23819.422    23819.422   -800.33066   -800.33066 
   62000   -8398.0877   -8398.0877   -8476.3144   -8476.3144    302.74546    302.74546    23764.667    23764.667    2774.7395    2774.7395 
Loop time of 225.925 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.53     | 225.53     | 225.53     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063745   | 0.063745   | 0.063745   |   0.0 |  0.03
Output  | 0.0001646  | 0.0001646  | 0.0001646  |   0.0 |  0.00
Modify  | 0.28525    | 0.28525    | 0.28525    |   0.0 |  0.13
Other   |            | 0.04385    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238974.0 ave      238974 max      238974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238974
Ave neighs/atom = 119.48700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.538920182095, Press = 2.14315972661694
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.0877   -8398.0877   -8476.3144   -8476.3144    302.74546    302.74546    23764.667    23764.667    2774.7395    2774.7395 
   63000   -8397.3507   -8397.3507   -8478.6269   -8478.6269    314.54719    314.54719    23775.057    23775.057    1791.2848    1791.2848 
Loop time of 233.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.370 ns/day, 64.835 hours/ns, 4.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    | 233        | 233        | 233        |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065447   | 0.065447   | 0.065447   |   0.0 |  0.03
Output  | 0.00017863 | 0.00017863 | 0.00017863 |   0.0 |  0.00
Modify  | 0.29633    | 0.29633    | 0.29633    |   0.0 |  0.13
Other   |            | 0.04535    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240134.0 ave      240134 max      240134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240134
Ave neighs/atom = 120.06700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.573234280983, Press = 0.748818141835159
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.3507   -8397.3507   -8478.6269   -8478.6269    314.54719    314.54719    23775.057    23775.057    1791.2848    1791.2848 
   64000   -8397.1867   -8397.1867   -8480.2338   -8480.2338    321.40093    321.40093    23790.032    23790.032    658.03077    658.03077 
Loop time of 208.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.415 ns/day, 57.841 hours/ns, 4.802 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.86     | 207.86     | 207.86     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058052   | 0.058052   | 0.058052   |   0.0 |  0.03
Output  | 0.00032937 | 0.00032937 | 0.00032937 |   0.0 |  0.00
Modify  | 0.26312    | 0.26312    | 0.26312    |   0.0 |  0.13
Other   |            | 0.0402     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4132.00 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239884.0 ave      239884 max      239884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239884
Ave neighs/atom = 119.94200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.56351777382, Press = 0.179964228013881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.1867   -8397.1867   -8480.2338   -8480.2338    321.40093    321.40093    23790.032    23790.032    658.03077    658.03077 
   65000   -8398.4713   -8398.4713   -8478.2488   -8478.2488     308.7472     308.7472    23811.884    23811.884   -777.48269   -777.48269 
Loop time of 289.472 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.298 ns/day, 80.409 hours/ns, 3.455 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    | 288.98     | 288.98     | 288.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077536   | 0.077536   | 0.077536   |   0.0 |  0.03
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.36151    | 0.36151    | 0.36151    |   0.0 |  0.12
Other   |            | 0.05117    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239514.0 ave      239514 max      239514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239514
Ave neighs/atom = 119.75700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.61276176488, Press = -0.0225143505817309
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.4713   -8398.4713   -8478.2488   -8478.2488     308.7472     308.7472    23811.884    23811.884   -777.48269   -777.48269 
   66000   -8396.7619   -8396.7619   -8477.7121   -8477.7121    313.28569    313.28569    23829.295    23829.295   -1868.5419   -1868.5419 
Loop time of 247.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.349 ns/day, 68.852 hours/ns, 4.034 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    | 247.44     | 247.44     | 247.44     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067934   | 0.067934   | 0.067934   |   0.0 |  0.03
Output  | 0.00031766 | 0.00031766 | 0.00031766 |   0.0 |  0.00
Modify  | 0.31419    | 0.31419    | 0.31419    |   0.0 |  0.13
Other   |            | 0.04669    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4131.00 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239320.0 ave      239320 max      239320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239320
Ave neighs/atom = 119.66000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.619638128898, Press = 0.629642862388116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.7619   -8396.7619   -8477.7121   -8477.7121    313.28569    313.28569    23829.295    23829.295   -1868.5419   -1868.5419 
   67000   -8400.8311   -8400.8311    -8479.956    -8479.956    306.22184    306.22184    23811.411    23811.411   -948.60372   -948.60372 
Loop time of 173.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.316 hours/ns, 5.749 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.61     | 173.61     | 173.61     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051677   | 0.051677   | 0.051677   |   0.0 |  0.03
Output  | 9.6259e-05 | 9.6259e-05 | 9.6259e-05 |   0.0 |  0.00
Modify  | 0.23315    | 0.23315    | 0.23315    |   0.0 |  0.13
Other   |            | 0.04055    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238952.0 ave      238952 max      238952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238952
Ave neighs/atom = 119.47600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.595123934593, Press = 1.47874701833018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8400.8311   -8400.8311    -8479.956    -8479.956    306.22184    306.22184    23811.411    23811.411   -948.60372   -948.60372 
   68000   -8396.8204   -8396.8204   -8479.0254   -8479.0254    318.14193    318.14193    23789.495    23789.495    877.97447    877.97447 
Loop time of 209.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.412 ns/day, 58.246 hours/ns, 4.769 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    | 209.32     | 209.32     | 209.32     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058621   | 0.058621   | 0.058621   |   0.0 |  0.03
Output  | 0.0001956  | 0.0001956  | 0.0001956  |   0.0 |  0.00
Modify  | 0.26805    | 0.26805    | 0.26805    |   0.0 |  0.13
Other   |            | 0.04221    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239184.0 ave      239184 max      239184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239184
Ave neighs/atom = 119.59200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.555392331861, Press = 1.55517695870648
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.8204   -8396.8204   -8479.0254   -8479.0254    318.14193    318.14193    23789.495    23789.495    877.97447    877.97447 
   69000   -8399.5694   -8399.5694    -8480.731    -8480.731    314.10401    314.10401    23766.902    23766.902    2134.1689    2134.1689 
Loop time of 220.849 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.391 ns/day, 61.347 hours/ns, 4.528 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    | 220.45     | 220.45     | 220.45     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063196   | 0.063196   | 0.063196   |   0.0 |  0.03
Output  | 0.00011823 | 0.00011823 | 0.00011823 |   0.0 |  0.00
Modify  | 0.28664    | 0.28664    | 0.28664    |   0.0 |  0.13
Other   |            | 0.04678    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239466.0 ave      239466 max      239466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239466
Ave neighs/atom = 119.73300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.54580981671, Press = 0.875867439121081
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.5694   -8399.5694    -8480.731    -8480.731    314.10401    314.10401    23766.902    23766.902    2134.1689    2134.1689 
   70000   -8398.7129   -8398.7129   -8478.7534   -8478.7534    309.76517    309.76517    23774.934    23774.934    1770.1906    1770.1906 
Loop time of 171.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.505 ns/day, 47.548 hours/ns, 5.842 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    | 170.86     | 170.86     | 170.86     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048264   | 0.048264   | 0.048264   |   0.0 |  0.03
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.22373    | 0.22373    | 0.22373    |   0.0 |  0.13
Other   |            | 0.03604    |            |       |  0.02

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:      239978.0 ave      239978 max      239978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239978
Ave neighs/atom = 119.98900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.548076404219, Press = -0.164998425571253
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.7129   -8398.7129   -8478.7534   -8478.7534    309.76517    309.76517    23774.934    23774.934    1770.1906    1770.1906 
   71000   -8396.6027   -8396.6027   -8478.2564   -8478.2564    316.00796    316.00796     23812.57     23812.57   -778.51351   -778.51351 
Loop time of 244.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.354 ns/day, 67.822 hours/ns, 4.096 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    | 243.74     | 243.74     | 243.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066803   | 0.066803   | 0.066803   |   0.0 |  0.03
Output  | 0.00031647 | 0.00031647 | 0.00031647 |   0.0 |  0.00
Modify  | 0.30764    | 0.30764    | 0.30764    |   0.0 |  0.13
Other   |            | 0.04575    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239720.0 ave      239720 max      239720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239720
Ave neighs/atom = 119.86000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.508944898337, Press = -0.746099622816875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.6027   -8396.6027   -8478.2564   -8478.2564    316.00796    316.00796     23812.57     23812.57   -778.51351   -778.51351 
   72000   -8399.2367   -8399.2367    -8480.992    -8480.992    316.40136    316.40136    23846.392    23846.392   -3373.0395   -3373.0395 
Loop time of 264.476 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.327 ns/day, 73.466 hours/ns, 3.781 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    | 264.02     | 264.02     | 264.02     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072062   | 0.072062   | 0.072062   |   0.0 |  0.03
Output  | 0.00010098 | 0.00010098 | 0.00010098 |   0.0 |  0.00
Modify  | 0.3327     | 0.3327     | 0.3327     |   0.0 |  0.13
Other   |            | 0.04922    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239190.0 ave      239190 max      239190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239190
Ave neighs/atom = 119.59500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.490317603951, Press = 0.110411341473891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.2367   -8399.2367    -8480.992    -8480.992    316.40136    316.40136    23846.392    23846.392   -3373.0395   -3373.0395 
   73000   -8398.2596   -8398.2596   -8480.5777   -8480.5777    318.57954    318.57954    23825.229    23825.229   -1881.8711   -1881.8711 
Loop time of 225.922 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.54     | 225.54     | 225.54     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062064   | 0.062064   | 0.062064   |   0.0 |  0.03
Output  | 0.00019193 | 0.00019193 | 0.00019193 |   0.0 |  0.00
Modify  | 0.2796     | 0.2796     | 0.2796     |   0.0 |  0.12
Other   |            | 0.04275    |            |       |  0.02

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:      238542.0 ave      238542 max      238542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238542
Ave neighs/atom = 119.27100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.470048589489, Press = 0.953976183200342
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.2596   -8398.2596   -8480.5777   -8480.5777    318.57954    318.57954    23825.229    23825.229   -1881.8711   -1881.8711 
   74000    -8398.858    -8398.858     -8479.13     -8479.13    310.66127    310.66127    23804.577    23804.577   -333.42181   -333.42181 
Loop time of 198.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.051 hours/ns, 5.046 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    | 197.84     | 197.84     | 197.84     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055592   | 0.055592   | 0.055592   |   0.0 |  0.03
Output  | 9.3165e-05 | 9.3165e-05 | 9.3165e-05 |   0.0 |  0.00
Modify  | 0.25064    | 0.25064    | 0.25064    |   0.0 |  0.13
Other   |            | 0.04113    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238734.0 ave      238734 max      238734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238734
Ave neighs/atom = 119.36700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.413783060234, Press = 1.20585166961346
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8398.858    -8398.858     -8479.13     -8479.13    310.66127    310.66127    23804.577    23804.577   -333.42181   -333.42181 
   75000   -8399.9373   -8399.9373   -8481.4826   -8481.4826    315.58898    315.58898    23788.593    23788.593    407.71814    407.71814 
Loop time of 168.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.874 hours/ns, 5.926 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    | 168.44     | 168.44     | 168.44     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047465   | 0.047465   | 0.047465   |   0.0 |  0.03
Output  | 9.9858e-05 | 9.9858e-05 | 9.9858e-05 |   0.0 |  0.00
Modify  | 0.22054    | 0.22054    | 0.22054    |   0.0 |  0.13
Other   |            | 0.03491    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4127.00 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239242.0 ave      239242 max      239242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239242
Ave neighs/atom = 119.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.389719257513, Press = 1.01182763244767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.9373   -8399.9373   -8481.4826   -8481.4826    315.58898    315.58898    23788.593    23788.593    407.71814    407.71814 
   76000   -8395.7414   -8395.7414   -8480.1911   -8480.1911    326.82912    326.82912    23783.428    23783.428    1180.5036    1180.5036 
Loop time of 142.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.608 ns/day, 39.452 hours/ns, 7.041 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.78     | 141.78     | 141.78     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039314   | 0.039314   | 0.039314   |   0.0 |  0.03
Output  | 0.00021075 | 0.00021075 | 0.00021075 |   0.0 |  0.00
Modify  | 0.18476    | 0.18476    | 0.18476    |   0.0 |  0.13
Other   |            | 0.02804    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239518.0 ave      239518 max      239518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239518
Ave neighs/atom = 119.75900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.360727151803, Press = 0.712522725726478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.7414   -8395.7414   -8480.1911   -8480.1911    326.82912    326.82912    23783.428    23783.428    1180.5036    1180.5036 
   77000   -8395.6704   -8395.6704   -8478.6992   -8478.6992    321.32993    321.32993    23771.409    23771.409    2178.5278    2178.5278 
Loop time of 141.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.268 hours/ns, 7.074 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.11     | 141.11     | 141.11     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03947    | 0.03947    | 0.03947    |   0.0 |  0.03
Output  | 0.00010289 | 0.00010289 | 0.00010289 |   0.0 |  0.00
Modify  | 0.18402    | 0.18402    | 0.18402    |   0.0 |  0.13
Other   |            | 0.02832    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239640.0 ave      239640 max      239640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239640
Ave neighs/atom = 119.82000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.35839477149, Press = -0.183196974164886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.6704   -8395.6704   -8478.6992   -8478.6992    321.32993    321.32993    23771.409    23771.409    2178.5278    2178.5278 
   78000     -8399.66     -8399.66   -8480.1169   -8480.1169    311.37629    311.37629    23806.288    23806.288   -533.51768   -533.51768 
Loop time of 141.964 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.609 ns/day, 39.434 hours/ns, 7.044 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.71     | 141.71     | 141.71     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0392     | 0.0392     | 0.0392     |   0.0 |  0.03
Output  | 0.00010445 | 0.00010445 | 0.00010445 |   0.0 |  0.00
Modify  | 0.18358    | 0.18358    | 0.18358    |   0.0 |  0.13
Other   |            | 0.02755    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239936.0 ave      239936 max      239936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239936
Ave neighs/atom = 119.96800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38080499763, Press = -0.809430438720804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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     -8399.66     -8399.66   -8480.1169   -8480.1169    311.37629    311.37629    23806.288    23806.288   -533.51768   -533.51768 
   79000    -8398.539    -8398.539   -8478.2374   -8478.2374    308.44091    308.44091    23829.344    23829.344   -1910.3464   -1910.3464 
Loop time of 141.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.612 ns/day, 39.224 hours/ns, 7.082 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    | 140.96     | 140.96     | 140.96     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038821   | 0.038821   | 0.038821   |   0.0 |  0.03
Output  | 0.00012537 | 0.00012537 | 0.00012537 |   0.0 |  0.00
Modify  | 0.18303    | 0.18303    | 0.18303    |   0.0 |  0.13
Other   |            | 0.02828    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4126.00 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239280.0 ave      239280 max      239280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239280
Ave neighs/atom = 119.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.404368614692, Press = 0.161085834255095
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8398.539    -8398.539   -8478.2374   -8478.2374    308.44091    308.44091    23829.344    23829.344   -1910.3464   -1910.3464 
   80000   -8398.0686   -8398.0686   -8479.1734   -8479.1734    313.88409    313.88409    23819.537    23819.537   -1222.5032   -1222.5032 
Loop time of 143.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.603 ns/day, 39.816 hours/ns, 6.977 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    | 143.08     | 143.08     | 143.08     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040085   | 0.040085   | 0.040085   |   0.0 |  0.03
Output  | 0.00010275 | 0.00010275 | 0.00010275 |   0.0 |  0.00
Modify  | 0.18763    | 0.18763    | 0.18763    |   0.0 |  0.13
Other   |            | 0.02928    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239100.0 ave      239100 max      239100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239100
Ave neighs/atom = 119.55000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440860708579, Press = 0.553519061446846
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.0686   -8398.0686   -8479.1734   -8479.1734    313.88409    313.88409    23819.537    23819.537   -1222.5032   -1222.5032 
   81000   -8396.1208   -8396.1208   -8477.2972   -8477.2972     314.1611     314.1611    23809.615    23809.615   -325.76315   -325.76315 
Loop time of 160.16 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.539 ns/day, 44.489 hours/ns, 6.244 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 159.88     | 159.88     | 159.88     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045405   | 0.045405   | 0.045405   |   0.0 |  0.03
Output  | 0.00017971 | 0.00017971 | 0.00017971 |   0.0 |  0.00
Modify  | 0.20695    | 0.20695    | 0.20695    |   0.0 |  0.13
Other   |            | 0.03247    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239020.0 ave      239020 max      239020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239020
Ave neighs/atom = 119.51000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.452772094327, Press = 0.865090797501489
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.1208   -8396.1208   -8477.2972   -8477.2972     314.1611     314.1611    23809.615    23809.615   -325.76315   -325.76315 
   82000   -8398.4002   -8398.4002   -8477.7395   -8477.7395    307.05158    307.05158    23792.504    23792.504    809.51345    809.51345 
Loop time of 191.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.450 ns/day, 53.317 hours/ns, 5.210 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    | 191.6      | 191.6      | 191.6      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053579   | 0.053579   | 0.053579   |   0.0 |  0.03
Output  | 0.00033393 | 0.00033393 | 0.00033393 |   0.0 |  0.00
Modify  | 0.24583    | 0.24583    | 0.24583    |   0.0 |  0.13
Other   |            | 0.03819    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239046.0 ave      239046 max      239046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239046
Ave neighs/atom = 119.52300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445200966206, Press = 1.23202730720801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.4002   -8398.4002   -8477.7395   -8477.7395    307.05158    307.05158    23792.504    23792.504    809.51345    809.51345 
   83000   -8398.9878   -8398.9878   -8479.7204   -8479.7204    312.44346    312.44346     23720.34     23720.34    5603.0733    5603.0733 
Loop time of 221.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.390 ns/day, 61.597 hours/ns, 4.510 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    | 221.36     | 221.36     | 221.36     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062017   | 0.062017   | 0.062017   |   0.0 |  0.03
Output  | 0.00025262 | 0.00025262 | 0.00025262 |   0.0 |  0.00
Modify  | 0.28376    | 0.28376    | 0.28376    |   0.0 |  0.13
Other   |            | 0.04447    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4124.00 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239622.0 ave      239622 max      239622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239622
Ave neighs/atom = 119.81100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433028060082, Press = 1.38799001058371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.9878   -8398.9878   -8479.7204   -8479.7204    312.44346    312.44346     23720.34     23720.34    5603.0733    5603.0733 
   84000   -8398.4819   -8398.4819   -8477.9072   -8477.9072    307.38381    307.38381    23766.123    23766.123    2538.0448    2538.0448 
Loop time of 173.739 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.261 hours/ns, 5.756 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    | 173.41     | 173.41     | 173.41     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051769   | 0.051769   | 0.051769   |   0.0 |  0.03
Output  | 0.00011128 | 0.00011128 | 0.00011128 |   0.0 |  0.00
Modify  | 0.23483    | 0.23483    | 0.23483    |   0.0 |  0.14
Other   |            | 0.04114    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240590.0 ave      240590 max      240590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240590
Ave neighs/atom = 120.29500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.385548351994, Press = 0.210088017670148
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.4819   -8398.4819   -8477.9072   -8477.9072    307.38381    307.38381    23766.123    23766.123    2538.0448    2538.0448 
   85000   -8397.7806   -8397.7806   -8477.5237   -8477.5237    308.61415    308.61415    23799.192    23799.192    378.76954    378.76954 
Loop time of 142.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.590 hours/ns, 7.016 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    | 142.27     | 142.27     | 142.27     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039743   | 0.039743   | 0.039743   |   0.0 |  0.03
Output  | 0.00019546 | 0.00019546 | 0.00019546 |   0.0 |  0.00
Modify  | 0.18562    | 0.18562    | 0.18562    |   0.0 |  0.13
Other   |            | 0.02899    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240066.0 ave      240066 max      240066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240066
Ave neighs/atom = 120.03300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.368051349423, Press = 0.129782032499775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8397.7806   -8397.7806   -8477.5237   -8477.5237    308.61415    308.61415    23799.192    23799.192    378.76954    378.76954 
   86000   -8393.6201   -8393.6201   -8477.4995   -8477.4995    324.62171    324.62171    23823.961    23823.961   -1168.6896   -1168.6896 
Loop time of 140.773 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.614 ns/day, 39.104 hours/ns, 7.104 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    | 140.52     | 140.52     | 140.52     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039131   | 0.039131   | 0.039131   |   0.0 |  0.03
Output  | 0.00010332 | 0.00010332 | 0.00010332 |   0.0 |  0.00
Modify  | 0.18432    | 0.18432    | 0.18432    |   0.0 |  0.13
Other   |            | 0.02921    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239368.0 ave      239368 max      239368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239368
Ave neighs/atom = 119.68400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.363628027805, Press = 0.171319418335214
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8393.6201   -8393.6201   -8477.4995   -8477.4995    324.62171    324.62171    23823.961    23823.961   -1168.6896   -1168.6896 
   87000   -8399.1283   -8399.1283   -8480.1474   -8480.1474    313.55246    313.55246    23826.249    23826.249     -1950.16     -1950.16 
Loop time of 145.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.595 ns/day, 40.336 hours/ns, 6.887 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.95     | 144.95     | 144.95     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040088   | 0.040088   | 0.040088   |   0.0 |  0.03
Output  | 0.00010361 | 0.00010361 | 0.00010361 |   0.0 |  0.00
Modify  | 0.18994    | 0.18994    | 0.18994    |   0.0 |  0.13
Other   |            | 0.02974    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4122.00 ave        4122 max        4122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239082.0 ave      239082 max      239082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239082
Ave neighs/atom = 119.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.382967857802, Press = 0.657540833491513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.1283   -8399.1283   -8480.1474   -8480.1474    313.55246    313.55246    23826.249    23826.249     -1950.16     -1950.16 
   88000    -8397.475    -8397.475   -8478.9685   -8478.9685    315.38834    315.38834    23814.876    23814.876   -993.82077   -993.82077 
Loop time of 135.558 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.637 ns/day, 37.655 hours/ns, 7.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.32     | 135.32     | 135.32     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038148   | 0.038148   | 0.038148   |   0.0 |  0.03
Output  | 0.00010565 | 0.00010565 | 0.00010565 |   0.0 |  0.00
Modify  | 0.17544    | 0.17544    | 0.17544    |   0.0 |  0.13
Other   |            | 0.02852    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4124.00 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238920.0 ave      238920 max      238920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238920
Ave neighs/atom = 119.46000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.402423340998, Press = 1.64650141645636
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8397.475    -8397.475   -8478.9685   -8478.9685    315.38834    315.38834    23814.876    23814.876   -993.82077   -993.82077 
   89000   -8399.4864   -8399.4864   -8479.1957   -8479.1957    308.48303    308.48303    23758.323    23758.323    2885.2051    2885.2051 
Loop time of 134.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.285 hours/ns, 7.450 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.99     | 133.99     | 133.99     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037547   | 0.037547   | 0.037547   |   0.0 |  0.03
Output  | 0.00010344 | 0.00010344 | 0.00010344 |   0.0 |  0.00
Modify  | 0.17452    | 0.17452    | 0.17452    |   0.0 |  0.13
Other   |            | 0.02763    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239238.0 ave      239238 max      239238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239238
Ave neighs/atom = 119.61900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400016012989, Press = 1.73124234241455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.4864   -8399.4864   -8479.1957   -8479.1957    308.48303    308.48303    23758.323    23758.323    2885.2051    2885.2051 
   90000   -8398.6018   -8398.6018   -8481.0528   -8481.0528    319.09377    319.09377    23772.889    23772.889    1726.3095    1726.3095 
Loop time of 141.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.299 hours/ns, 7.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.23     | 141.23     | 141.23     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039224   | 0.039224   | 0.039224   |   0.0 |  0.03
Output  | 9.9079e-05 | 9.9079e-05 | 9.9079e-05 |   0.0 |  0.00
Modify  | 0.18357    | 0.18357    | 0.18357    |   0.0 |  0.13
Other   |            | 0.02782    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4123.00 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239946.0 ave      239946 max      239946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239946
Ave neighs/atom = 119.97300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.365140290228, Press = 0.632514985647721
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.6018   -8398.6018   -8481.0528   -8481.0528    319.09377    319.09377    23772.889    23772.889    1726.3095    1726.3095 
   91000   -8398.8711   -8398.8711   -8480.7182   -8480.7182     316.7567     316.7567    23786.268    23786.268    845.15779    845.15779 
Loop time of 152.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.334 hours/ns, 6.562 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    | 152.13     | 152.13     | 152.13     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042496   | 0.042496   | 0.042496   |   0.0 |  0.03
Output  | 0.00010271 | 0.00010271 | 0.00010271 |   0.0 |  0.00
Modify  | 0.19706    | 0.19706    | 0.19706    |   0.0 |  0.13
Other   |            | 0.03195    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4125.00 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239810.0 ave      239810 max      239810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239810
Ave neighs/atom = 119.90500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.366121696264, Press = 0.243891442800146
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.8711   -8398.8711   -8480.7182   -8480.7182     316.7567     316.7567    23786.268    23786.268    845.15779    845.15779 
   92000   -8398.7901   -8398.7901   -8478.6195   -8478.6195    308.94818    308.94818    23808.086    23808.086    -474.5313    -474.5313 
Loop time of 188.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.459 ns/day, 52.254 hours/ns, 5.316 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    | 187.77     | 187.77     | 187.77     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056449   | 0.056449   | 0.056449   |   0.0 |  0.03
Output  | 0.00018013 | 0.00018013 | 0.00018013 |   0.0 |  0.00
Modify  | 0.24601    | 0.24601    | 0.24601    |   0.0 |  0.13
Other   |            | 0.04171    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239608.0 ave      239608 max      239608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239608
Ave neighs/atom = 119.80400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.336076830493, Press = 0.238106811652009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8398.7901   -8398.7901   -8478.6195   -8478.6195    308.94818    308.94818    23808.086    23808.086    -474.5313    -474.5313 
   93000    -8401.384    -8401.384    -8480.139    -8480.139     304.7902     304.7902     23828.06     23828.06   -2140.7075   -2140.7075 
Loop time of 163.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.529 ns/day, 45.349 hours/ns, 6.125 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    | 162.96     | 162.96     | 162.96     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048616   | 0.048616   | 0.048616   |   0.0 |  0.03
Output  | 9.449e-05  | 9.449e-05  | 9.449e-05  |   0.0 |  0.00
Modify  | 0.21409    | 0.21409    | 0.21409    |   0.0 |  0.13
Other   |            | 0.03593    |            |       |  0.02

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:      239188.0 ave      239188 max      239188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239188
Ave neighs/atom = 119.59400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.321637011492, Press = 0.392619358883972
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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    -8401.384    -8401.384    -8480.139    -8480.139     304.7902     304.7902     23828.06     23828.06   -2140.7075   -2140.7075 
   94000   -8396.6172   -8396.6172   -8476.8766   -8476.8766    310.61181    310.61181    23830.442    23830.442   -1752.2158   -1752.2158 
Loop time of 178.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.696 hours/ns, 5.589 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    | 178.58     | 178.58     | 178.58     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052976   | 0.052976   | 0.052976   |   0.0 |  0.03
Output  | 0.00017461 | 0.00017461 | 0.00017461 |   0.0 |  0.00
Modify  | 0.23371    | 0.23371    | 0.23371    |   0.0 |  0.13
Other   |            | 0.03865    |            |       |  0.02

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:      238964.0 ave      238964 max      238964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238964
Ave neighs/atom = 119.48200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.291731754061, Press = 1.44736236728374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8396.6172   -8396.6172   -8476.8766   -8476.8766    310.61181    310.61181    23830.442    23830.442   -1752.2158   -1752.2158 
   95000   -8399.6492   -8399.6492   -8479.5751   -8479.5751    309.32142    309.32142    23780.051    23780.051    1385.9733    1385.9733 
Loop time of 213.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.404 ns/day, 59.441 hours/ns, 4.673 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 213.61     | 213.61     | 213.61     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060206   | 0.060206   | 0.060206   |   0.0 |  0.03
Output  | 0.00010272 | 0.00010272 | 0.00010272 |   0.0 |  0.00
Modify  | 0.27554    | 0.27554    | 0.27554    |   0.0 |  0.13
Other   |            | 0.04423    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4121.00 ave        4121 max        4121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      238832.0 ave      238832 max      238832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238832
Ave neighs/atom = 119.41600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.280719567119, Press = 1.69478125850378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.6492   -8399.6492   -8479.5751   -8479.5751    309.32142    309.32142    23780.051    23780.051    1385.9733    1385.9733 
   96000   -8395.4245   -8395.4245   -8478.0348   -8478.0348    319.71003    319.71003    23786.796    23786.796    1143.5838    1143.5838 
Loop time of 173.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.247 hours/ns, 5.757 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.38     | 173.38     | 173.38     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049001   | 0.049001   | 0.049001   |   0.0 |  0.03
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.22439    | 0.22439    | 0.22439    |   0.0 |  0.13
Other   |            | 0.03854    |            |       |  0.02

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:      239664.0 ave      239664 max      239664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239664
Ave neighs/atom = 119.83200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.282249664518, Press = 0.609048318659447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8395.4245   -8395.4245   -8478.0348   -8478.0348    319.71003    319.71003    23786.796    23786.796    1143.5838    1143.5838 
   97000   -8399.6676   -8399.6676   -8479.1057   -8479.1057    307.43363    307.43363    23785.309    23785.309    981.22267    981.22267 
Loop time of 148.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.292 hours/ns, 6.727 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    | 148.38     | 148.38     | 148.38     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042674   | 0.042674   | 0.042674   |   0.0 |  0.03
Output  | 9.8779e-05 | 9.8779e-05 | 9.8779e-05 |   0.0 |  0.00
Modify  | 0.19483    | 0.19483    | 0.19483    |   0.0 |  0.13
Other   |            | 0.03565    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239600.0 ave      239600 max      239600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239600
Ave neighs/atom = 119.80000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.296043700325, Press = 0.361183846274344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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   -8399.6676   -8399.6676   -8479.1057   -8479.1057    307.43363    307.43363    23785.309    23785.309    981.22267    981.22267 
   98000   -8400.4379   -8400.4379    -8479.664    -8479.664    306.61311    306.61311    23797.438    23797.438   -45.458748   -45.458748 
Loop time of 181.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.349 hours/ns, 5.517 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.93     | 180.93     | 180.93     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052566   | 0.052566   | 0.052566   |   0.0 |  0.03
Output  | 0.0002402  | 0.0002402  | 0.0002402  |   0.0 |  0.00
Modify  | 0.23586    | 0.23586    | 0.23586    |   0.0 |  0.13
Other   |            | 0.0406     |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4129.00 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239722.0 ave      239722 max      239722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239722
Ave neighs/atom = 119.86100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
23800.6280007539

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0