# 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.8510001525282864*${_u_distance}
variable latticeconst_converted equal 2.8510001525282864*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100015252829
Lattice spacing in x,y,z = 2.8510002 2.8510002 2.8510002
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.510002 28.510002 28.510002)
  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.510002 28.510002 28.510002)
  create_atoms CPU = 0.002 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_AsadiZaeemNouranian_2015_Fe__MO_492310898779_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 23173.504770342    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.504770342/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.504770342/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.504770342/(1*1*${_u_distance})
variable      V0_metal equal 23173.504770342/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23173.504770342*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_492310898779_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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -8504.252    -8504.252   -8579.9993   -8579.9993       293.15       293.15    23173.505    23173.505    3491.3751    3491.3751 
    1000   -8425.5122   -8425.5122   -8500.2806   -8500.2806    289.36157    289.36157     23336.61     23336.61    2834.7235    2834.7235 
Loop time of 147.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.049 hours/ns, 6.767 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.29     | 147.29     | 147.29     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094559   | 0.094559   | 0.094559   |   0.0 |  0.06
Output  | 0.0001929  | 0.0001929  | 0.0001929  |   0.0 |  0.00
Modify  | 0.33528    | 0.33528    | 0.33528    |   0.0 |  0.23
Other   |            | 0.05818    |            |       |  0.04

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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8425.5122   -8425.5122   -8500.2806   -8500.2806    289.36157    289.36157     23336.61     23336.61    2834.7235    2834.7235 
    2000   -8425.0801   -8425.0801   -8498.7904   -8498.7904    285.26645    285.26645     23362.15     23362.15    1213.5005    1213.5005 
Loop time of 153.111 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.531 hours/ns, 6.531 timesteps/s
100.1% 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.62     | 152.62     | 152.62     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095473   | 0.095473   | 0.095473   |   0.0 |  0.06
Output  | 0.00018942 | 0.00018942 | 0.00018942 |   0.0 |  0.00
Modify  | 0.33612    | 0.33612    | 0.33612    |   0.0 |  0.22
Other   |            | 0.05689    |            |       |  0.04

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:      128406.0 ave      128406 max      128406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128406
Ave neighs/atom = 64.203000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8425.0801   -8425.0801   -8498.7904   -8498.7904    285.26645    285.26645     23362.15     23362.15    1213.5005    1213.5005 
    3000   -8426.5582   -8426.5582   -8505.5494   -8505.5494    305.70407    305.70407    23349.096    23349.096     1485.752     1485.752 
Loop time of 153.003 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.501 hours/ns, 6.536 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.51     | 152.51     | 152.51     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095439   | 0.095439   | 0.095439   |   0.0 |  0.06
Output  | 0.00018872 | 0.00018872 | 0.00018872 |   0.0 |  0.00
Modify  | 0.33568    | 0.33568    | 0.33568    |   0.0 |  0.22
Other   |            | 0.05742    |            |       |  0.04

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:      128310.0 ave      128310 max      128310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128310
Ave neighs/atom = 64.155000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8426.5582   -8426.5582   -8505.5494   -8505.5494    305.70407    305.70407    23349.096    23349.096     1485.752     1485.752 
    4000   -8424.6101   -8424.6101    -8499.102    -8499.102    288.29144    288.29144     23353.55     23353.55    1943.5214    1943.5214 
Loop time of 153.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.562 ns/day, 42.667 hours/ns, 6.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    | 153.11     | 153.11     | 153.11     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097097   | 0.097097   | 0.097097   |   0.0 |  0.06
Output  | 0.00018883 | 0.00018883 | 0.00018883 |   0.0 |  0.00
Modify  | 0.33653    | 0.33653    | 0.33653    |   0.0 |  0.22
Other   |            | 0.05693    |            |       |  0.04

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:      128236.0 ave      128236 max      128236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128236
Ave neighs/atom = 64.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8424.6101   -8424.6101    -8499.102    -8499.102    288.29144    288.29144     23353.55     23353.55    1943.5214    1943.5214 
    5000   -8427.0803   -8427.0803   -8503.5132   -8503.5132    295.80333    295.80333    23359.497    23359.497    983.88955    983.88955 
Loop time of 152.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.499 hours/ns, 6.536 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.51     | 152.51     | 152.51     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096342   | 0.096342   | 0.096342   |   0.0 |  0.06
Output  | 0.00015242 | 0.00015242 | 0.00015242 |   0.0 |  0.00
Modify  | 0.33713    | 0.33713    | 0.33713    |   0.0 |  0.22
Other   |            | 0.05809    |            |       |  0.04

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:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 288.593513367928, Press = -1161.72954760019
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8427.0803   -8427.0803   -8503.5132   -8503.5132    295.80333    295.80333    23359.497    23359.497    983.88955    983.88955 
    6000   -8425.1302   -8425.1302   -8498.3631   -8498.3631    283.41867    283.41867    23376.547    23376.547    446.94876    446.94876 
Loop time of 153.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.528 hours/ns, 6.532 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.59     | 152.59     | 152.59     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096035   | 0.096035   | 0.096035   |   0.0 |  0.06
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.35337    | 0.35337    | 0.35337    |   0.0 |  0.23
Other   |            | 0.0575     |            |       |  0.04

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:      128302.0 ave      128302 max      128302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128302
Ave neighs/atom = 64.151000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.079641365408, Press = -112.857762884515
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8425.1302   -8425.1302   -8498.3631   -8498.3631    283.41867    283.41867    23376.547    23376.547    446.94876    446.94876 
    7000   -8429.3726   -8429.3726   -8500.5895   -8500.5895    275.61677    275.61677    23372.043    23372.043      327.151      327.151 
Loop time of 154.915 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.558 ns/day, 43.032 hours/ns, 6.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    | 154.4      | 154.4      | 154.4      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096146   | 0.096146   | 0.096146   |   0.0 |  0.06
Output  | 0.00019142 | 0.00019142 | 0.00019142 |   0.0 |  0.00
Modify  | 0.35837    | 0.35837    | 0.35837    |   0.0 |  0.23
Other   |            | 0.05737    |            |       |  0.04

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:      128346.0 ave      128346 max      128346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128346
Ave neighs/atom = 64.173000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.465574345394, Press = -66.618826067935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8429.3726   -8429.3726   -8500.5895   -8500.5895    275.61677    275.61677    23372.043    23372.043      327.151      327.151 
    8000   -8425.8947   -8425.8947   -8501.1452   -8501.1452    291.22698    291.22698     23396.27     23396.27    -1275.139    -1275.139 
Loop time of 152.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.452 hours/ns, 6.543 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.32     | 152.32     | 152.32     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095656   | 0.095656   | 0.095656   |   0.0 |  0.06
Output  | 0.00015204 | 0.00015204 | 0.00015204 |   0.0 |  0.00
Modify  | 0.35272    | 0.35272    | 0.35272    |   0.0 |  0.23
Other   |            | 0.05689    |            |       |  0.04

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:      128264.0 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.055411924538, Press = -58.0054890955884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8425.8947   -8425.8947   -8501.1452   -8501.1452    291.22698    291.22698     23396.27     23396.27    -1275.139    -1275.139 
    9000   -8422.8854   -8422.8854   -8499.0134   -8499.0134    294.62349    294.62349    23405.673    23405.673   -1497.5718   -1497.5718 
Loop time of 152.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.428 hours/ns, 6.547 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.24     | 152.24     | 152.24     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095306   | 0.095306   | 0.095306   |   0.0 |  0.06
Output  | 0.00018722 | 0.00018722 | 0.00018722 |   0.0 |  0.00
Modify  | 0.35199    | 0.35199    | 0.35199    |   0.0 |  0.23
Other   |            | 0.05675    |            |       |  0.04

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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.641311574104, Press = -23.3986191966619
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8422.8854   -8422.8854   -8499.0134   -8499.0134    294.62349    294.62349    23405.673    23405.673   -1497.5718   -1497.5718 
   10000   -8425.3649   -8425.3649   -8504.2641   -8504.2641    305.34822    305.34822    23401.933    23401.933   -1854.2405   -1854.2405 
Loop time of 152.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.366 hours/ns, 6.557 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.01     | 152.01     | 152.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095075   | 0.095075   | 0.095075   |   0.0 |  0.06
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.35134    | 0.35134    | 0.35134    |   0.0 |  0.23
Other   |            | 0.05675    |            |       |  0.04

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:      128276.0 ave      128276 max      128276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128276
Ave neighs/atom = 64.138000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.269396400314, Press = -15.054870624252
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8425.3649   -8425.3649   -8504.2641   -8504.2641    305.34822    305.34822    23401.933    23401.933   -1854.2405   -1854.2405 
   11000   -8425.1552   -8425.1552   -8502.0685   -8502.0685    297.66225    297.66225    23397.694    23397.694   -1305.2918   -1305.2918 
Loop time of 152.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.324 hours/ns, 6.563 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    | 151.86     | 151.86     | 151.86     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095615   | 0.095615   | 0.095615   |   0.0 |  0.06
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.3515     | 0.3515     | 0.3515     |   0.0 |  0.23
Other   |            | 0.05716    |            |       |  0.04

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:      128230.0 ave      128230 max      128230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.176451594699, Press = -11.3854787507117
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8425.1552   -8425.1552   -8502.0685   -8502.0685    297.66225    297.66225    23397.694    23397.694   -1305.2918   -1305.2918 
   12000   -8431.2355   -8431.2355   -8504.4068   -8504.4068    283.18063    283.18063    23396.011    23396.011    -1854.381    -1854.381 
Loop time of 152.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.382 hours/ns, 6.554 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.07     | 152.07     | 152.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095308   | 0.095308   | 0.095308   |   0.0 |  0.06
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.35185    | 0.35185    | 0.35185    |   0.0 |  0.23
Other   |            | 0.05655    |            |       |  0.04

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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.122573867748, Press = -8.02049193766933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8431.2355   -8431.2355   -8504.4068   -8504.4068    283.18063    283.18063    23396.011    23396.011    -1854.381    -1854.381 
   13000    -8425.831    -8425.831   -8501.4374   -8501.4374    292.60453    292.60453    23422.187    23422.187   -3114.1289   -3114.1289 
Loop time of 152.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.424 hours/ns, 6.548 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.22     | 152.22     | 152.22     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095516   | 0.095516   | 0.095516   |   0.0 |  0.06
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.35079    | 0.35079    | 0.35079    |   0.0 |  0.23
Other   |            | 0.05641    |            |       |  0.04

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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.719562955009, Press = -2.88455392600861
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -8425.831    -8425.831   -8501.4374   -8501.4374    292.60453    292.60453    23422.187    23422.187   -3114.1289   -3114.1289 
   14000   -8425.5726   -8425.5726   -8502.3565   -8502.3565     297.1618     297.1618    23438.668    23438.668   -4369.0116   -4369.0116 
Loop time of 152.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.365 hours/ns, 6.557 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.01     | 152.01     | 152.01     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095665   | 0.095665   | 0.095665   |   0.0 |  0.06
Output  | 0.00015265 | 0.00015265 | 0.00015265 |   0.0 |  0.00
Modify  | 0.35148    | 0.35148    | 0.35148    |   0.0 |  0.23
Other   |            | 0.05702    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.803185208462, Press = 7.38195951453321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8425.5726   -8425.5726   -8502.3565   -8502.3565     297.1618     297.1618    23438.668    23438.668   -4369.0116   -4369.0116 
   15000   -8423.2757   -8423.2757   -8501.5127   -8501.5127    302.78539    302.78539    23390.866    23390.866   -825.44484   -825.44484 
Loop time of 152.738 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.427 hours/ns, 6.547 timesteps/s
100.1% 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.23     | 152.23     | 152.23     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09557    | 0.09557    | 0.09557    |   0.0 |  0.06
Output  | 0.00015356 | 0.00015356 | 0.00015356 |   0.0 |  0.00
Modify  | 0.35159    | 0.35159    | 0.35159    |   0.0 |  0.23
Other   |            | 0.05672    |            |       |  0.04

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:      128226.0 ave      128226 max      128226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128226
Ave neighs/atom = 64.113000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.927260103103, Press = 0.0789765641289921
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8423.2757   -8423.2757   -8501.5127   -8501.5127    302.78539    302.78539    23390.866    23390.866   -825.44484   -825.44484 
   16000   -8427.0811   -8427.0811   -8502.4292   -8502.4292    291.60484    291.60484    23382.235    23382.235   -473.17325   -473.17325 
Loop time of 152.641 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.400 hours/ns, 6.551 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.14     | 152.14     | 152.14     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095543   | 0.095543   | 0.095543   |   0.0 |  0.06
Output  | 0.00018657 | 0.00018657 | 0.00018657 |   0.0 |  0.00
Modify  | 0.35149    | 0.35149    | 0.35149    |   0.0 |  0.23
Other   |            | 0.05687    |            |       |  0.04

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:      128320.0 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.890791247792, Press = -0.399617515043604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8427.0811   -8427.0811   -8502.4292   -8502.4292    291.60484    291.60484    23382.235    23382.235   -473.17325   -473.17325 
   17000    -8423.814    -8423.814   -8500.0332   -8500.0332    294.97647    294.97647    23378.838    23378.838      112.823      112.823 
Loop time of 152.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.499 hours/ns, 6.536 timesteps/s
100.1% 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.49     | 152.49     | 152.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095595   | 0.095595   | 0.095595   |   0.0 |  0.06
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.35176    | 0.35176    | 0.35176    |   0.0 |  0.23
Other   |            | 0.05667    |            |       |  0.04

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:      128296.0 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921387383435, Press = -0.712500124879138
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -8423.814    -8423.814   -8500.0332   -8500.0332    294.97647    294.97647    23378.838    23378.838      112.823      112.823 
   18000   -8428.3976   -8428.3976   -8503.8566   -8503.8566    292.03426    292.03426    23358.354    23358.354    931.42419    931.42419 
Loop time of 152.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.439 hours/ns, 6.545 timesteps/s
100.1% 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.27     | 152.27     | 152.27     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095053   | 0.095053   | 0.095053   |   0.0 |  0.06
Output  | 0.00015501 | 0.00015501 | 0.00015501 |   0.0 |  0.00
Modify  | 0.3533     | 0.3533     | 0.3533     |   0.0 |  0.23
Other   |            | 0.05717    |            |       |  0.04

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:      128302.0 ave      128302 max      128302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128302
Ave neighs/atom = 64.151000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.841841512426, Press = -0.257867207990757
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8428.3976   -8428.3976   -8503.8566   -8503.8566    292.03426    292.03426    23358.354    23358.354    931.42419    931.42419 
   19000    -8423.575    -8423.575   -8500.6637   -8500.6637    298.34129    298.34129    23335.987    23335.987    3050.8711    3050.8711 
Loop time of 171.85 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.736 hours/ns, 5.819 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.27     | 171.27     | 171.27     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10565    | 0.10565    | 0.10565    |   0.0 |  0.06
Output  | 0.0001514  | 0.0001514  | 0.0001514  |   0.0 |  0.00
Modify  | 0.41657    | 0.41657    | 0.41657    |   0.0 |  0.24
Other   |            | 0.06191    |            |       |  0.04

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:      128354.0 ave      128354 max      128354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128354
Ave neighs/atom = 64.177000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.800126017697, Press = 2.04051997155633
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -8423.575    -8423.575   -8500.6637   -8500.6637    298.34129    298.34129    23335.987    23335.987    3050.8711    3050.8711 
   20000   -8424.7848   -8424.7848   -8500.9455   -8500.9455    294.75012    294.75012    23334.046    23334.046    3157.3028    3157.3028 
Loop time of 152.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.452 hours/ns, 6.543 timesteps/s
100.1% 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.32     | 152.32     | 152.32     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095181   | 0.095181   | 0.095181   |   0.0 |  0.06
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.35184    | 0.35184    | 0.35184    |   0.0 |  0.23
Other   |            | 0.05784    |            |       |  0.04

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:      128348.0 ave      128348 max      128348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128348
Ave neighs/atom = 64.174000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845165937642, Press = -0.290817186100178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8424.7848   -8424.7848   -8500.9455   -8500.9455    294.75012    294.75012    23334.046    23334.046    3157.3028    3157.3028 
   21000   -8422.9342   -8422.9342   -8499.1961   -8499.1961    295.14127    295.14127     23360.87     23360.87    1508.6448    1508.6448 
Loop time of 153.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.563 ns/day, 42.652 hours/ns, 6.513 timesteps/s
100.1% 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.04     | 153.04     | 153.04     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095662   | 0.095662   | 0.095662   |   0.0 |  0.06
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.35519    | 0.35519    | 0.35519    |   0.0 |  0.23
Other   |            | 0.05715    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128370.0 ave      128370 max      128370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128370
Ave neighs/atom = 64.185000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945562495342, Press = -2.1317558445033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8422.9342   -8422.9342   -8499.1961   -8499.1961    295.14127    295.14127     23360.87     23360.87    1508.6448    1508.6448 
   22000   -8424.9224   -8424.9224    -8501.108    -8501.108      294.846      294.846    23361.635    23361.635    1080.5559    1080.5559 
Loop time of 152.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.452 hours/ns, 6.543 timesteps/s
100.1% 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.32     | 152.32     | 152.32     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096237   | 0.096237   | 0.096237   |   0.0 |  0.06
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.35324    | 0.35324    | 0.35324    |   0.0 |  0.23
Other   |            | 0.05744    |            |       |  0.04

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:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.918466814599, Press = -3.28525965059679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8424.9224   -8424.9224    -8501.108    -8501.108      294.846      294.846    23361.635    23361.635    1080.5559    1080.5559 
   23000   -8426.1084   -8426.1084   -8502.2494   -8502.2494    294.67339    294.67339     23352.42     23352.42    1597.6823    1597.6823 
Loop time of 152.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.479 hours/ns, 6.539 timesteps/s
100.1% 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.42     | 152.42     | 152.42     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096159   | 0.096159   | 0.096159   |   0.0 |  0.06
Output  | 0.00015556 | 0.00015556 | 0.00015556 |   0.0 |  0.00
Modify  | 0.35282    | 0.35282    | 0.35282    |   0.0 |  0.23
Other   |            | 0.05755    |            |       |  0.04

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:      128296.0 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885913561198, Press = -4.28493247307687
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8426.1084   -8426.1084   -8502.2494   -8502.2494    294.67339    294.67339     23352.42     23352.42    1597.6823    1597.6823 
   24000   -8425.8884   -8425.8884   -8501.0316   -8501.0316    290.81215    290.81215    23349.575    23349.575    1924.0489    1924.0489 
Loop time of 152.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.391 hours/ns, 6.553 timesteps/s
100.1% 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.1      | 152.1      | 152.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096318   | 0.096318   | 0.096318   |   0.0 |  0.06
Output  | 0.00018921 | 0.00018921 | 0.00018921 |   0.0 |  0.00
Modify  | 0.35304    | 0.35304    | 0.35304    |   0.0 |  0.23
Other   |            | 0.05735    |            |       |  0.04

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:      128316.0 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128316
Ave neighs/atom = 64.158000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914987699289, Press = -4.95388106769248
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8425.8884   -8425.8884   -8501.0316   -8501.0316    290.81215    290.81215    23349.575    23349.575    1924.0489    1924.0489 
   25000   -8424.3489   -8424.3489   -8499.5017   -8499.5017    290.84925    290.84925    23351.686    23351.686    2105.5164    2105.5164 
Loop time of 152.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.413 hours/ns, 6.549 timesteps/s
100.1% 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.18     | 152.18     | 152.18     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096206   | 0.096206   | 0.096206   |   0.0 |  0.06
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.35179    | 0.35179    | 0.35179    |   0.0 |  0.23
Other   |            | 0.05796    |            |       |  0.04

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:      128352.0 ave      128352 max      128352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128352
Ave neighs/atom = 64.176000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.911724843779, Press = -7.23996077412509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8424.3489   -8424.3489   -8499.5017   -8499.5017    290.84925    290.84925    23351.686    23351.686    2105.5164    2105.5164 
   26000   -8427.8524   -8427.8524   -8503.1106   -8503.1106    291.25704    291.25704    23370.389    23370.389    202.67088    202.67088 
Loop time of 153.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.567 hours/ns, 6.526 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.73     | 152.73     | 152.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096074   | 0.096074   | 0.096074   |   0.0 |  0.06
Output  | 0.00015298 | 0.00015298 | 0.00015298 |   0.0 |  0.00
Modify  | 0.35343    | 0.35343    | 0.35343    |   0.0 |  0.23
Other   |            | 0.05785    |            |       |  0.04

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:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.864996623238, Press = -5.44635795032695
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8427.8524   -8427.8524   -8503.1106   -8503.1106    291.25704    291.25704    23370.389    23370.389    202.67088    202.67088 
   27000   -8423.3032   -8423.3032   -8501.3596   -8501.3596    302.08645    302.08645    23390.191    23390.191   -898.91075   -898.91075 
Loop time of 152.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.464 hours/ns, 6.542 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.36     | 152.36     | 152.36     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096074   | 0.096074   | 0.096074   |   0.0 |  0.06
Output  | 0.00015351 | 0.00015351 | 0.00015351 |   0.0 |  0.00
Modify  | 0.35383    | 0.35383    | 0.35383    |   0.0 |  0.23
Other   |            | 0.05806    |            |       |  0.04

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:      128260.0 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.786236805424, Press = -3.71715138447256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8423.3032   -8423.3032   -8501.3596   -8501.3596    302.08645    302.08645    23390.191    23390.191   -898.91075   -898.91075 
   28000   -8429.3865   -8429.3865   -8503.9363   -8503.9363    288.51534    288.51534    23384.465    23384.465   -892.15435   -892.15435 
Loop time of 152.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.487 hours/ns, 6.538 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.45     | 152.45     | 152.45     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09612    | 0.09612    | 0.09612    |   0.0 |  0.06
Output  | 0.00015251 | 0.00015251 | 0.00015251 |   0.0 |  0.00
Modify  | 0.35254    | 0.35254    | 0.35254    |   0.0 |  0.23
Other   |            | 0.05781    |            |       |  0.04

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:      128324.0 ave      128324 max      128324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128324
Ave neighs/atom = 64.162000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755265380206, Press = -3.11968681058543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8429.3865   -8429.3865   -8503.9363   -8503.9363    288.51534    288.51534    23384.465    23384.465   -892.15435   -892.15435 
   29000   -8424.6588   -8424.6588   -8502.9717   -8502.9717    303.07884    303.07884    23401.754    23401.754   -1909.8248   -1909.8248 
Loop time of 152.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.448 hours/ns, 6.544 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.31     | 152.31     | 152.31     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095857   | 0.095857   | 0.095857   |   0.0 |  0.06
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.35272    | 0.35272    | 0.35272    |   0.0 |  0.23
Other   |            | 0.05795    |            |       |  0.04

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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.648059850447, Press = -2.90069849610449
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8424.6588   -8424.6588   -8502.9717   -8502.9717    303.07884    303.07884    23401.754    23401.754   -1909.8248   -1909.8248 
   30000   -8427.9639   -8427.9639   -8502.0795   -8502.0795     286.8349     286.8349    23420.624    23420.624   -3157.4533   -3157.4533 
Loop time of 152.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.494 hours/ns, 6.537 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.47     | 152.47     | 152.47     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096314   | 0.096314   | 0.096314   |   0.0 |  0.06
Output  | 0.00046089 | 0.00046089 | 0.00046089 |   0.0 |  0.00
Modify  | 0.35293    | 0.35293    | 0.35293    |   0.0 |  0.23
Other   |            | 0.05791    |            |       |  0.04

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:      128246.0 ave      128246 max      128246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128246
Ave neighs/atom = 64.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.646303103125, Press = -2.28029815757885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8427.9639   -8427.9639   -8502.0795   -8502.0795     286.8349     286.8349    23420.624    23420.624   -3157.4533   -3157.4533 
   31000   -8423.4456   -8423.4456   -8499.3806   -8499.3806    293.87648    293.87648    23424.261    23424.261   -2892.6355   -2892.6355 
Loop time of 152.916 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.477 hours/ns, 6.540 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.41     | 152.41     | 152.41     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09572    | 0.09572    | 0.09572    |   0.0 |  0.06
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.35227    | 0.35227    | 0.35227    |   0.0 |  0.23
Other   |            | 0.05784    |            |       |  0.04

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:      128288.0 ave      128288 max      128288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128288
Ave neighs/atom = 64.144000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.609791072635, Press = -0.479137350292147
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8423.4456   -8423.4456   -8499.3806   -8499.3806    293.87648    293.87648    23424.261    23424.261   -2892.6355   -2892.6355 
   32000     -8425.23     -8425.23    -8500.482    -8500.482    291.23322    291.23322    23408.624    23408.624   -1934.4013   -1934.4013 
Loop time of 159.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.540 ns/day, 44.423 hours/ns, 6.253 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.39     | 159.39     | 159.39     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098868   | 0.098868   | 0.098868   |   0.0 |  0.06
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.37492    | 0.37492    | 0.37492    |   0.0 |  0.23
Other   |            | 0.05993    |            |       |  0.04

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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.649996870109, Press = -0.177831333218111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000     -8425.23     -8425.23    -8500.482    -8500.482    291.23322    291.23322    23408.624    23408.624   -1934.4013   -1934.4013 
   33000   -8426.9668   -8426.9668   -8500.8809   -8500.8809     286.0554     286.0554    23394.457    23394.457   -1159.6326   -1159.6326 
Loop time of 167.177 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.517 ns/day, 46.438 hours/ns, 5.982 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    | 166.61     | 166.61     | 166.61     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10383    | 0.10383    | 0.10383    |   0.0 |  0.06
Output  | 0.00015021 | 0.00015021 | 0.00015021 |   0.0 |  0.00
Modify  | 0.40264    | 0.40264    | 0.40264    |   0.0 |  0.24
Other   |            | 0.06108    |            |       |  0.04

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:      128268.0 ave      128268 max      128268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128268
Ave neighs/atom = 64.134000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776635138868, Press = -0.226136639183929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8426.9668   -8426.9668   -8500.8809   -8500.8809     286.0554     286.0554    23394.457    23394.457   -1159.6326   -1159.6326 
   34000   -8422.1792   -8422.1792   -8498.3909   -8498.3909    294.94731    294.94731    23381.401    23381.401    206.06833    206.06833 
Loop time of 152.357 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.321 hours/ns, 6.564 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    | 151.85     | 151.85     | 151.85     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094842   | 0.094842   | 0.094842   |   0.0 |  0.06
Output  | 0.00015187 | 0.00015187 | 0.00015187 |   0.0 |  0.00
Modify  | 0.35176    | 0.35176    | 0.35176    |   0.0 |  0.23
Other   |            | 0.05847    |            |       |  0.04

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:      128230.0 ave      128230 max      128230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813506349424, Press = 0.488869918368321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8422.1792   -8422.1792   -8498.3909   -8498.3909    294.94731    294.94731    23381.401    23381.401    206.06833    206.06833 
   35000   -8425.9269   -8425.9269   -8500.7635   -8500.7635    289.62546    289.62546    23372.653    23372.653    396.09443    396.09443 
Loop time of 152.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.296 hours/ns, 6.568 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    | 151.76     | 151.76     | 151.76     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095109   | 0.095109   | 0.095109   |   0.0 |  0.06
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.35259    | 0.35259    | 0.35259    |   0.0 |  0.23
Other   |            | 0.05844    |            |       |  0.04

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:      128312.0 ave      128312 max      128312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128312
Ave neighs/atom = 64.156000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820067643927, Press = -0.00408794228121867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8425.9269   -8425.9269   -8500.7635   -8500.7635    289.62546    289.62546    23372.653    23372.653    396.09443    396.09443 
   36000   -8425.0201   -8425.0201   -8502.6489   -8502.6489    300.43122    300.43122    23358.885    23358.885    1274.2405    1274.2405 
Loop time of 152.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.257 hours/ns, 6.574 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    | 151.62     | 151.62     | 151.62     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094922   | 0.094922   | 0.094922   |   0.0 |  0.06
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.35213    | 0.35213    | 0.35213    |   0.0 |  0.23
Other   |            | 0.05792    |            |       |  0.04

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:      128296.0 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784195678385, Press = 0.161615432208807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8425.0201   -8425.0201   -8502.6489   -8502.6489    300.43122    300.43122    23358.885    23358.885    1274.2405    1274.2405 
   37000   -8425.4425   -8425.4425   -8501.5233   -8501.5233    294.44052    294.44052     23342.28     23342.28    2469.7108    2469.7108 
Loop time of 152.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.315 hours/ns, 6.565 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    | 151.83     | 151.83     | 151.83     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094563   | 0.094563   | 0.094563   |   0.0 |  0.06
Output  | 0.00015234 | 0.00015234 | 0.00015234 |   0.0 |  0.00
Modify  | 0.35273    | 0.35273    | 0.35273    |   0.0 |  0.23
Other   |            | 0.05789    |            |       |  0.04

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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.133000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.75072462663, Press = 0.027807625779501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8425.4425   -8425.4425   -8501.5233   -8501.5233    294.44052    294.44052     23342.28     23342.28    2469.7108    2469.7108 
   38000   -8426.1379   -8426.1379   -8500.8417   -8500.8417    289.11134    289.11134     23322.43     23322.43    3888.5946    3888.5946 
Loop time of 152.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.277 hours/ns, 6.570 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.69     | 151.69     | 151.69     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095366   | 0.095366   | 0.095366   |   0.0 |  0.06
Output  | 0.00015175 | 0.00015175 | 0.00015175 |   0.0 |  0.00
Modify  | 0.35193    | 0.35193    | 0.35193    |   0.0 |  0.23
Other   |            | 0.05826    |            |       |  0.04

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:      128294.0 ave      128294 max      128294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128294
Ave neighs/atom = 64.147000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755995828553, Press = -0.541067561705761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8426.1379   -8426.1379   -8500.8417   -8500.8417    289.11134    289.11134     23322.43     23322.43    3888.5946    3888.5946 
   39000   -8427.9446   -8427.9446   -8503.0737   -8503.0737    290.75712    290.75712    23345.015    23345.015    2023.3926    2023.3926 
Loop time of 152.327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.313 hours/ns, 6.565 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    | 151.82     | 151.82     | 151.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095107   | 0.095107   | 0.095107   |   0.0 |  0.06
Output  | 0.00018967 | 0.00018967 | 0.00018967 |   0.0 |  0.00
Modify  | 0.35251    | 0.35251    | 0.35251    |   0.0 |  0.23
Other   |            | 0.05816    |            |       |  0.04

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:      128386.0 ave      128386 max      128386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128386
Ave neighs/atom = 64.193000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.653828590833, Press = -1.32230740935561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8427.9446   -8427.9446   -8503.0737   -8503.0737    290.75712    290.75712    23345.015    23345.015    2023.3926    2023.3926 
   40000    -8425.037    -8425.037   -8501.5616   -8501.5616    296.15828    296.15828    23364.189    23364.189    1011.8022    1011.8022 
Loop time of 152.328 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.313 hours/ns, 6.565 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    | 151.82     | 151.82     | 151.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094941   | 0.094941   | 0.094941   |   0.0 |  0.06
Output  | 0.00015274 | 0.00015274 | 0.00015274 |   0.0 |  0.00
Modify  | 0.35189    | 0.35189    | 0.35189    |   0.0 |  0.23
Other   |            | 0.05837    |            |       |  0.04

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:      128322.0 ave      128322 max      128322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128322
Ave neighs/atom = 64.161000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.654684647475, Press = -1.22067475848189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -8425.037    -8425.037   -8501.5616   -8501.5616    296.15828    296.15828    23364.189    23364.189    1011.8022    1011.8022 
   41000   -8426.9211   -8426.9211    -8503.101    -8503.101    294.82405    294.82405    23358.198    23358.198    1061.3476    1061.3476 
Loop time of 152.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.254 hours/ns, 6.574 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    | 151.61     | 151.61     | 151.61     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09537    | 0.09537    | 0.09537    |   0.0 |  0.06
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.35227    | 0.35227    | 0.35227    |   0.0 |  0.23
Other   |            | 0.0582     |            |       |  0.04

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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.594685672274, Press = -1.59731283629212
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8426.9211   -8426.9211    -8503.101    -8503.101    294.82405    294.82405    23358.198    23358.198    1061.3476    1061.3476 
   42000    -8425.941    -8425.941   -8501.8992   -8501.8992     293.9663     293.9663    23352.181    23352.181    1647.9268    1647.9268 
Loop time of 152.296 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.304 hours/ns, 6.566 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    | 151.79     | 151.79     | 151.79     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094935   | 0.094935   | 0.094935   |   0.0 |  0.06
Output  | 0.00018596 | 0.00018596 | 0.00018596 |   0.0 |  0.00
Modify  | 0.35243    | 0.35243    | 0.35243    |   0.0 |  0.23
Other   |            | 0.0582     |            |       |  0.04

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:      128282.0 ave      128282 max      128282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128282
Ave neighs/atom = 64.141000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.597667308077, Press = -2.16163965351338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000    -8425.941    -8425.941   -8501.8992   -8501.8992     293.9663     293.9663    23352.181    23352.181    1647.9268    1647.9268 
   43000   -8426.4807   -8426.4807   -8502.3341   -8502.3341    293.56021    293.56021    23342.905    23342.905    2291.2641    2291.2641 
Loop time of 152.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.568 ns/day, 42.287 hours/ns, 6.569 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    | 151.73     | 151.73     | 151.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095161   | 0.095161   | 0.095161   |   0.0 |  0.06
Output  | 0.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.35246    | 0.35246    | 0.35246    |   0.0 |  0.23
Other   |            | 0.05847    |            |       |  0.04

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:      128316.0 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128316
Ave neighs/atom = 64.158000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.54618012943, Press = -3.22780254578035
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8426.4807   -8426.4807   -8502.3341   -8502.3341    293.56021    293.56021    23342.905    23342.905    2291.2641    2291.2641 
   44000   -8426.6899   -8426.6899   -8501.4876   -8501.4876    289.47484    289.47484    23359.037    23359.037    1254.9749    1254.9749 
Loop time of 152.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.304 hours/ns, 6.566 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    | 151.79     | 151.79     | 151.79     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094774   | 0.094774   | 0.094774   |   0.0 |  0.06
Output  | 0.00015255 | 0.00015255 | 0.00015255 |   0.0 |  0.00
Modify  | 0.35277    | 0.35277    | 0.35277    |   0.0 |  0.23
Other   |            | 0.0581     |            |       |  0.04

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:      128328.0 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.526736128521, Press = -3.2825892769329
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8426.6899   -8426.6899   -8501.4876   -8501.4876    289.47484    289.47484    23359.037    23359.037    1254.9749    1254.9749 
   45000    -8425.596    -8425.596   -8501.7927   -8501.7927    294.88884    294.88884    23383.049    23383.049   -363.19086   -363.19086 
Loop time of 152.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.291 hours/ns, 6.568 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    | 151.75     | 151.75     | 151.75     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094179   | 0.094179   | 0.094179   |   0.0 |  0.06
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.35066    | 0.35066    | 0.35066    |   0.0 |  0.23
Other   |            | 0.05781    |            |       |  0.04

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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.133000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.47111365215, Press = -2.69332445603743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -8425.596    -8425.596   -8501.7927   -8501.7927    294.88884    294.88884    23383.049    23383.049   -363.19086   -363.19086 
   46000   -8427.3555   -8427.3555   -8502.6297   -8502.6297    291.31904    291.31904    23388.598    23388.598   -995.81503   -995.81503 
Loop time of 151.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.192 hours/ns, 6.584 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    | 151.39     | 151.39     | 151.39     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093751   | 0.093751   | 0.093751   |   0.0 |  0.06
Output  | 0.00015272 | 0.00015272 | 0.00015272 |   0.0 |  0.00
Modify  | 0.35136    | 0.35136    | 0.35136    |   0.0 |  0.23
Other   |            | 0.05925    |            |       |  0.04

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:      128252.0 ave      128252 max      128252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128252
Ave neighs/atom = 64.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.481790452254, Press = -2.44580209183897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8427.3555   -8427.3555   -8502.6297   -8502.6297    291.31904    291.31904    23388.598    23388.598   -995.81503   -995.81503 
   47000   -8421.6687   -8421.6687   -8498.4001   -8498.4001    296.95857    296.95857    23408.887    23408.887   -1651.7523   -1651.7523 
Loop time of 152.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.295 hours/ns, 6.568 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    | 151.76     | 151.76     | 151.76     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09409    | 0.09409    | 0.09409    |   0.0 |  0.06
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.35056    | 0.35056    | 0.35056    |   0.0 |  0.23
Other   |            | 0.05925    |            |       |  0.04

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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.551573863463, Press = -1.93462108070635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8421.6687   -8421.6687   -8498.4001   -8498.4001    296.95857    296.95857    23408.887    23408.887   -1651.7523   -1651.7523 
   48000   -8425.6413   -8425.6413   -8501.2166   -8501.2166    292.48401    292.48401    23395.967    23395.967   -1233.3892   -1233.3892 
Loop time of 151.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.216 hours/ns, 6.580 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    | 151.47     | 151.47     | 151.47     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094294   | 0.094294   | 0.094294   |   0.0 |  0.06
Output  | 0.00015298 | 0.00015298 | 0.00015298 |   0.0 |  0.00
Modify  | 0.35051    | 0.35051    | 0.35051    |   0.0 |  0.23
Other   |            | 0.05869    |            |       |  0.04

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:      128264.0 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.592304352434, Press = -1.36626607684635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8425.6413   -8425.6413   -8501.2166   -8501.2166    292.48401    292.48401    23395.967    23395.967   -1233.3892   -1233.3892 
   49000   -8429.2351   -8429.2351   -8501.4903   -8501.4903    279.63504    279.63504    23375.225    23375.225   -37.741255   -37.741255 
Loop time of 150.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.761 hours/ns, 6.652 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.84     | 149.84     | 149.84     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09311    | 0.09311    | 0.09311    |   0.0 |  0.06
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.34875    | 0.34875    | 0.34875    |   0.0 |  0.23
Other   |            | 0.05869    |            |       |  0.04

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:      128304.0 ave      128304 max      128304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128304
Ave neighs/atom = 64.152000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.630275348681, Press = -0.859148286695117
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8429.2351   -8429.2351   -8501.4903   -8501.4903    279.63504    279.63504    23375.225    23375.225   -37.741255   -37.741255 
   50000   -8424.6233   -8424.6233   -8499.1571   -8499.1571    288.45335    288.45335    23380.712    23380.712    53.411573    53.411573 
Loop time of 150.134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.575 ns/day, 41.704 hours/ns, 6.661 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.63     | 149.63     | 149.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093509   | 0.093509   | 0.093509   |   0.0 |  0.06
Output  | 0.00018973 | 0.00018973 | 0.00018973 |   0.0 |  0.00
Modify  | 0.34775    | 0.34775    | 0.34775    |   0.0 |  0.23
Other   |            | 0.05912    |            |       |  0.04

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:      128288.0 ave      128288 max      128288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128288
Ave neighs/atom = 64.144000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.603073313559, Press = -0.691351744573702
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8424.6233   -8424.6233   -8499.1571   -8499.1571    288.45335    288.45335    23380.712    23380.712    53.411573    53.411573 
   51000   -8427.7174   -8427.7174   -8501.6799   -8501.6799    286.24261    286.24261    23384.217    23384.217    -590.6056    -590.6056 
Loop time of 149.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.475 hours/ns, 6.697 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.81     | 148.81     | 148.81     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093194   | 0.093194   | 0.093194   |   0.0 |  0.06
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.34676    | 0.34676    | 0.34676    |   0.0 |  0.23
Other   |            | 0.05889    |            |       |  0.04

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:      128332.0 ave      128332 max      128332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128332
Ave neighs/atom = 64.166000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.599638942893, Press = -0.651017344593932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8427.7174   -8427.7174   -8501.6799   -8501.6799    286.24261    286.24261    23384.217    23384.217    -590.6056    -590.6056 
   52000   -8425.3785   -8425.3785    -8501.773    -8501.773    295.65458    295.65458    23392.295    23392.295   -1146.8997   -1146.8997 
Loop time of 149.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.461 hours/ns, 6.700 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.76     | 148.76     | 148.76     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092461   | 0.092461   | 0.092461   |   0.0 |  0.06
Output  | 0.00014672 | 0.00014672 | 0.00014672 |   0.0 |  0.00
Modify  | 0.34567    | 0.34567    | 0.34567    |   0.0 |  0.23
Other   |            | 0.05845    |            |       |  0.04

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:      128306.0 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.557068411014, Press = 0.359473093554384
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8425.3785   -8425.3785    -8501.773    -8501.773    295.65458    295.65458    23392.295    23392.295   -1146.8997   -1146.8997 
   53000   -8428.5253   -8428.5253   -8503.7395   -8503.7395    291.08671    291.08671    23380.096    23380.096     -615.538     -615.538 
Loop time of 149.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.503 hours/ns, 6.693 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.91     | 148.91     | 148.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093674   | 0.093674   | 0.093674   |   0.0 |  0.06
Output  | 0.00015329 | 0.00015329 | 0.00015329 |   0.0 |  0.00
Modify  | 0.34522    | 0.34522    | 0.34522    |   0.0 |  0.23
Other   |            | 0.05874    |            |       |  0.04

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:      128250.0 ave      128250 max      128250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128250
Ave neighs/atom = 64.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.561361522603, Press = 0.466438324236125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8428.5253   -8428.5253   -8503.7395   -8503.7395    291.08671    291.08671    23380.096    23380.096     -615.538     -615.538 
   54000   -8425.5402   -8425.5402   -8502.4363   -8502.4363    297.59581    297.59581    23372.314    23372.314    206.91415    206.91415 
Loop time of 149.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.575 hours/ns, 6.681 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.17     | 149.17     | 149.17     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09348    | 0.09348    | 0.09348    |   0.0 |  0.06
Output  | 0.00018344 | 0.00018344 | 0.00018344 |   0.0 |  0.00
Modify  | 0.34643    | 0.34643    | 0.34643    |   0.0 |  0.23
Other   |            | 0.05861    |            |       |  0.04

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:      128252.0 ave      128252 max      128252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128252
Ave neighs/atom = 64.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.517039745047, Press = 0.738307291292952
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8425.5402   -8425.5402   -8502.4363   -8502.4363    297.59581    297.59581    23372.314    23372.314    206.91415    206.91415 
   55000   -8424.6442   -8424.6442   -8500.7764   -8500.7764    294.63935    294.63935    23369.221    23369.221    696.53103    696.53103 
Loop time of 149.345 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.485 hours/ns, 6.696 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.85     | 148.85     | 148.85     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092593   | 0.092593   | 0.092593   |   0.0 |  0.06
Output  | 0.00014365 | 0.00014365 | 0.00014365 |   0.0 |  0.00
Modify  | 0.34676    | 0.34676    | 0.34676    |   0.0 |  0.23
Other   |            | 0.05862    |            |       |  0.04

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:      128300.0 ave      128300 max      128300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128300
Ave neighs/atom = 64.150000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.503462336986, Press = 0.0977389125375547
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8424.6442   -8424.6442   -8500.7764   -8500.7764    294.63935    294.63935    23369.221    23369.221    696.53103    696.53103 
   56000   -8427.8546   -8427.8546   -8504.0202   -8504.0202    294.76875    294.76875    23364.107    23364.107    553.57371    553.57371 
Loop time of 150.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.937 hours/ns, 6.624 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    | 150.47     | 150.47     | 150.47     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093236   | 0.093236   | 0.093236   |   0.0 |  0.06
Output  | 0.00014359 | 0.00014359 | 0.00014359 |   0.0 |  0.00
Modify  | 0.34928    | 0.34928    | 0.34928    |   0.0 |  0.23
Other   |            | 0.05913    |            |       |  0.04

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:      128290.0 ave      128290 max      128290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128290
Ave neighs/atom = 64.145000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.459636506626, Press = -0.586751021387546
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8427.8546   -8427.8546   -8504.0202   -8504.0202    294.76875    294.76875    23364.107    23364.107    553.57371    553.57371 
   57000   -8426.6223   -8426.6223   -8503.0671   -8503.0671    295.84908    295.84908    23369.884    23369.884    331.41002    331.41002 
Loop time of 149.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.514 hours/ns, 6.691 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.95     | 148.95     | 148.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092059   | 0.092059   | 0.092059   |   0.0 |  0.06
Output  | 0.00022243 | 0.00022243 | 0.00022243 |   0.0 |  0.00
Modify  | 0.34704    | 0.34704    | 0.34704    |   0.0 |  0.23
Other   |            | 0.05815    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4117.00 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.456828909674, Press = -0.844091361807039
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8426.6223   -8426.6223   -8503.0671   -8503.0671    295.84908    295.84908    23369.884    23369.884    331.41002    331.41002 
   58000    -8424.108    -8424.108   -8500.3309   -8500.3309    294.99017    294.99017    23367.802    23367.802    815.58093    815.58093 
Loop time of 149.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.623 hours/ns, 6.674 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.35     | 149.35     | 149.35     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092834   | 0.092834   | 0.092834   |   0.0 |  0.06
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.34608    | 0.34608    | 0.34608    |   0.0 |  0.23
Other   |            | 0.05837    |            |       |  0.04

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:      128264.0 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.46224128484, Press = -0.942742744631752
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -8424.108    -8424.108   -8500.3309   -8500.3309    294.99017    294.99017    23367.802    23367.802    815.58093    815.58093 
   59000   -8424.7053   -8424.7053   -8501.5803   -8501.5803    297.51425    297.51425    23346.031    23346.031    2187.9898    2187.9898 
Loop time of 149.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.527 hours/ns, 6.689 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        | 149        | 149        |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092574   | 0.092574   | 0.092574   |   0.0 |  0.06
Output  | 0.00014737 | 0.00014737 | 0.00014737 |   0.0 |  0.00
Modify  | 0.34649    | 0.34649    | 0.34649    |   0.0 |  0.23
Other   |            | 0.05879    |            |       |  0.04

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:      128264.0 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.526976982012, Press = -1.54776114821731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8424.7053   -8424.7053   -8501.5803   -8501.5803    297.51425    297.51425    23346.031    23346.031    2187.9898    2187.9898 
   60000   -8425.1249   -8425.1249   -8501.4698   -8501.4698     295.4629     295.4629    23346.213    23346.213    2107.5901    2107.5901 
Loop time of 149.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.454 hours/ns, 6.701 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.74     | 148.74     | 148.74     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093093   | 0.093093   | 0.093093   |   0.0 |  0.06
Output  | 0.000192   | 0.000192   | 0.000192   |   0.0 |  0.00
Modify  | 0.34569    | 0.34569    | 0.34569    |   0.0 |  0.23
Other   |            | 0.05874    |            |       |  0.04

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:      128274.0 ave      128274 max      128274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128274
Ave neighs/atom = 64.137000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.534461559233, Press = -2.07561076009089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8425.1249   -8425.1249   -8501.4698   -8501.4698     295.4629     295.4629    23346.213    23346.213    2107.5901    2107.5901 
   61000   -8423.5526   -8423.5526   -8500.9229   -8500.9229    299.43119    299.43119    23365.629    23365.629    824.74165    824.74165 
Loop time of 149.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.645 hours/ns, 6.670 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.42     | 149.42     | 149.42     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093186   | 0.093186   | 0.093186   |   0.0 |  0.06
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.34682    | 0.34682    | 0.34682    |   0.0 |  0.23
Other   |            | 0.05887    |            |       |  0.04

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:      128342.0 ave      128342 max      128342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128342
Ave neighs/atom = 64.171000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.599654943377, Press = -2.21829508607364
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8423.5526   -8423.5526   -8500.9229   -8500.9229    299.43119    299.43119    23365.629    23365.629    824.74165    824.74165 
   62000   -8425.2686   -8425.2686   -8499.7402   -8499.7402    288.21274    288.21274      23376.6      23376.6    179.89464    179.89464 
Loop time of 149.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.609 hours/ns, 6.676 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.29     | 149.29     | 149.29     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093087   | 0.093087   | 0.093087   |   0.0 |  0.06
Output  | 0.00015236 | 0.00015236 | 0.00015236 |   0.0 |  0.00
Modify  | 0.34747    | 0.34747    | 0.34747    |   0.0 |  0.23
Other   |            | 0.05805    |            |       |  0.04

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:      128262.0 ave      128262 max      128262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128262
Ave neighs/atom = 64.131000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.606337259642, Press = -1.54495222176839
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8425.2686   -8425.2686   -8499.7402   -8499.7402    288.21274    288.21274      23376.6      23376.6    179.89464    179.89464 
   63000   -8425.1096   -8425.1096   -8500.6402   -8500.6402    292.31106    292.31106     23388.09     23388.09   -634.76941   -634.76941 
Loop time of 149.592 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.553 hours/ns, 6.685 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.09     | 149.09     | 149.09     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093354   | 0.093354   | 0.093354   |   0.0 |  0.06
Output  | 0.00014555 | 0.00014555 | 0.00014555 |   0.0 |  0.00
Modify  | 0.34614    | 0.34614    | 0.34614    |   0.0 |  0.23
Other   |            | 0.05818    |            |       |  0.04

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:      128360.0 ave      128360 max      128360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128360
Ave neighs/atom = 64.180000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.649864564325, Press = -1.40689632673251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8425.1096   -8425.1096   -8500.6402   -8500.6402    292.31106    292.31106     23388.09     23388.09   -634.76941   -634.76941 
   64000   -8424.1819   -8424.1819   -8500.8695   -8500.8695    296.78906    296.78906    23391.997    23391.997   -951.20793   -951.20793 
Loop time of 149.695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.582 hours/ns, 6.680 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.2      | 149.2      | 149.2      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092325   | 0.092325   | 0.092325   |   0.0 |  0.06
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.34726    | 0.34726    | 0.34726    |   0.0 |  0.23
Other   |            | 0.05924    |            |       |  0.04

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:      128332.0 ave      128332 max      128332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128332
Ave neighs/atom = 64.166000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.637027489872, Press = -1.04699189412152
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8424.1819   -8424.1819   -8500.8695   -8500.8695    296.78906    296.78906    23391.997    23391.997   -951.20793   -951.20793 
   65000   -8425.6552   -8425.6552   -8499.5596   -8499.5596    286.01774    286.01774    23408.488    23408.488   -1953.8332   -1953.8332 
Loop time of 149.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.546 hours/ns, 6.686 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.07     | 149.07     | 149.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093262   | 0.093262   | 0.093262   |   0.0 |  0.06
Output  | 0.00014544 | 0.00014544 | 0.00014544 |   0.0 |  0.00
Modify  | 0.34725    | 0.34725    | 0.34725    |   0.0 |  0.23
Other   |            | 0.05732    |            |       |  0.04

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4118.00 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128326.0 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.642134074576, Press = -1.33932005257693
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8425.6552   -8425.6552   -8499.5596   -8499.5596    286.01774    286.01774    23408.488    23408.488   -1953.8332   -1953.8332 
   66000   -8430.5413   -8430.5413   -8503.6777   -8503.6777    283.04525    283.04525    23430.162    23430.162   -4209.9167   -4209.9167 
Loop time of 149.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.515 hours/ns, 6.691 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.96     | 148.96     | 148.96     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092768   | 0.092768   | 0.092768   |   0.0 |  0.06
Output  | 0.00014572 | 0.00014572 | 0.00014572 |   0.0 |  0.00
Modify  | 0.34735    | 0.34735    | 0.34735    |   0.0 |  0.23
Other   |            | 0.05761    |            |       |  0.04

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:      128270.0 ave      128270 max      128270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128270
Ave neighs/atom = 64.135000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.634534739158, Press = -1.07509339679376
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8430.5413   -8430.5413   -8503.6777   -8503.6777    283.04525    283.04525    23430.162    23430.162   -4209.9167   -4209.9167 
   67000   -8425.4288   -8425.4288   -8500.4349   -8500.4349    290.28154    290.28154    23412.155    23412.155   -2343.7808   -2343.7808 
Loop time of 151.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.163 hours/ns, 6.588 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    | 151.28     | 151.28     | 151.28     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094768   | 0.094768   | 0.094768   |   0.0 |  0.06
Output  | 0.00014752 | 0.00014752 | 0.00014752 |   0.0 |  0.00
Modify  | 0.34932    | 0.34932    | 0.34932    |   0.0 |  0.23
Other   |            | 0.05918    |            |       |  0.04

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:      128250.0 ave      128250 max      128250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128250
Ave neighs/atom = 64.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.596240645491, Press = -0.475152536958357
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8425.4288   -8425.4288   -8500.4349   -8500.4349    290.28154    290.28154    23412.155    23412.155   -2343.7808   -2343.7808 
   68000   -8427.4471   -8427.4471   -8502.0034   -8502.0034     288.5405     288.5405    23391.777    23391.777   -1246.6905   -1246.6905 
Loop time of 149.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.537 hours/ns, 6.687 timesteps/s
100.1% 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.04     | 149.04     | 149.04     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092113   | 0.092113   | 0.092113   |   0.0 |  0.06
Output  | 0.0001864  | 0.0001864  | 0.0001864  |   0.0 |  0.00
Modify  | 0.34542    | 0.34542    | 0.34542    |   0.0 |  0.23
Other   |            | 0.05833    |            |       |  0.04

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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.591324707926, Press = -0.403414817724083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8427.4471   -8427.4471   -8502.0034   -8502.0034     288.5405     288.5405    23391.777    23391.777   -1246.6905   -1246.6905 
   69000   -8425.5428   -8425.5428   -8502.0464   -8502.0464    296.07693    296.07693    23386.717    23386.717   -781.85137   -781.85137 
Loop time of 149.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.483 hours/ns, 6.696 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.84     | 148.84     | 148.84     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092801   | 0.092801   | 0.092801   |   0.0 |  0.06
Output  | 0.00014834 | 0.00014834 | 0.00014834 |   0.0 |  0.00
Modify  | 0.34567    | 0.34567    | 0.34567    |   0.0 |  0.23
Other   |            | 0.05825    |            |       |  0.04

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:      128246.0 ave      128246 max      128246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128246
Ave neighs/atom = 64.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.550940374655, Press = -0.412102629158766
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8425.5428   -8425.5428   -8502.0464   -8502.0464    296.07693    296.07693    23386.717    23386.717   -781.85137   -781.85137 
   70000   -8426.6147   -8426.6147   -8500.9594   -8500.9594    287.72186    287.72186    23380.144    23380.144   -167.64642   -167.64642 
Loop time of 149.111 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.420 hours/ns, 6.706 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.61     | 148.61     | 148.61     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093103   | 0.093103   | 0.093103   |   0.0 |  0.06
Output  | 0.00014611 | 0.00014611 | 0.00014611 |   0.0 |  0.00
Modify  | 0.34551    | 0.34551    | 0.34551    |   0.0 |  0.23
Other   |            | 0.05882    |            |       |  0.04

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:      128276.0 ave      128276 max      128276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128276
Ave neighs/atom = 64.138000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.555557970074, Press = -0.230180394997757
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8426.6147   -8426.6147   -8500.9594   -8500.9594    287.72186    287.72186    23380.144    23380.144   -167.64642   -167.64642 
   71000   -8422.9164   -8422.9164   -8496.7293   -8496.7293    285.66353    285.66353    23370.523    23370.523    1089.8281    1089.8281 
Loop time of 149.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.541 hours/ns, 6.687 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.05     | 149.05     | 149.05     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093164   | 0.093164   | 0.093164   |   0.0 |  0.06
Output  | 0.00014383 | 0.00014383 | 0.00014383 |   0.0 |  0.00
Modify  | 0.34615    | 0.34615    | 0.34615    |   0.0 |  0.23
Other   |            | 0.0583     |            |       |  0.04

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:      128298.0 ave      128298 max      128298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128298
Ave neighs/atom = 64.149000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.586244223325, Press = 1.03750474207642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8422.9164   -8422.9164   -8496.7293   -8496.7293    285.66353    285.66353    23370.523    23370.523    1089.8281    1089.8281 
   72000   -8425.9748   -8425.9748    -8501.043    -8501.043    290.52164    290.52164    23356.672    23356.672    1424.5252    1424.5252 
Loop time of 149.641 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.567 hours/ns, 6.683 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.15     | 149.15     | 149.15     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093413   | 0.093413   | 0.093413   |   0.0 |  0.06
Output  | 0.00014646 | 0.00014646 | 0.00014646 |   0.0 |  0.00
Modify  | 0.34466    | 0.34466    | 0.34466    |   0.0 |  0.23
Other   |            | 0.05801    |            |       |  0.04

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:      128340.0 ave      128340 max      128340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128340
Ave neighs/atom = 64.170000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.607616424137, Press = 0.327564634659862
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8425.9748   -8425.9748    -8501.043    -8501.043    290.52164    290.52164    23356.672    23356.672    1424.5252    1424.5252 
   73000   -8422.1886   -8422.1886   -8500.8753   -8500.8753    304.52581    304.52581    23364.977    23364.977    1085.4262    1085.4262 
Loop time of 149.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.550 hours/ns, 6.685 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.08     | 149.08     | 149.08     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093025   | 0.093025   | 0.093025   |   0.0 |  0.06
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.34637    | 0.34637    | 0.34637    |   0.0 |  0.23
Other   |            | 0.05841    |            |       |  0.04

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:      128302.0 ave      128302 max      128302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128302
Ave neighs/atom = 64.151000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.652932116069, Press = -0.206776734365308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8422.1886   -8422.1886   -8500.8753   -8500.8753    304.52581    304.52581    23364.977    23364.977    1085.4262    1085.4262 
   74000   -8424.8004   -8424.8004   -8500.0261   -8500.0261    291.13116    291.13116    23362.923    23362.923    1128.0642    1128.0642 
Loop time of 149.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.663 hours/ns, 6.667 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.49     | 149.49     | 149.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093925   | 0.093925   | 0.093925   |   0.0 |  0.06
Output  | 0.00014329 | 0.00014329 | 0.00014329 |   0.0 |  0.00
Modify  | 0.34699    | 0.34699    | 0.34699    |   0.0 |  0.23
Other   |            | 0.05851    |            |       |  0.04

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:      128278.0 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.652918192541, Press = -0.308771373738985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8424.8004   -8424.8004   -8500.0261   -8500.0261    291.13116    291.13116    23362.923    23362.923    1128.0642    1128.0642 
   75000   -8424.4813   -8424.4813   -8501.0029   -8501.0029     296.1465     296.1465    23362.835    23362.835    1165.8514    1165.8514 
Loop time of 149.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.606 hours/ns, 6.676 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.28     | 149.28     | 149.28     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09191    | 0.09191    | 0.09191    |   0.0 |  0.06
Output  | 0.0001447  | 0.0001447  | 0.0001447  |   0.0 |  0.00
Modify  | 0.34652    | 0.34652    | 0.34652    |   0.0 |  0.23
Other   |            | 0.0588     |            |       |  0.04

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:      128328.0 ave      128328 max      128328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128328
Ave neighs/atom = 64.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.634446465342, Press = -0.426051467090434
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8424.4813   -8424.4813   -8501.0029   -8501.0029     296.1465     296.1465    23362.835    23362.835    1165.8514    1165.8514 
   76000   -8427.0906   -8427.0906    -8503.918    -8503.918     297.3301     297.3301    23331.187    23331.187     2925.548     2925.548 
Loop time of 149.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.548 hours/ns, 6.686 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.07     | 149.07     | 149.07     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093344   | 0.093344   | 0.093344   |   0.0 |  0.06
Output  | 0.00014407 | 0.00014407 | 0.00014407 |   0.0 |  0.00
Modify  | 0.34639    | 0.34639    | 0.34639    |   0.0 |  0.23
Other   |            | 0.05873    |            |       |  0.04

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:      128250.0 ave      128250 max      128250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128250
Ave neighs/atom = 64.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.644407472407, Press = -0.623042171071476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8427.0906   -8427.0906    -8503.918    -8503.918     297.3301     297.3301    23331.187    23331.187     2925.548     2925.548 
   77000   -8423.1748   -8423.1748   -8498.8023   -8498.8023    292.68629    292.68629    23326.736    23326.736    3890.1591    3890.1591 
Loop time of 149.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.479 hours/ns, 6.697 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.83     | 148.83     | 148.83     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0931     | 0.0931     | 0.0931     |   0.0 |  0.06
Output  | 0.00014277 | 0.00014277 | 0.00014277 |   0.0 |  0.00
Modify  | 0.34572    | 0.34572    | 0.34572    |   0.0 |  0.23
Other   |            | 0.05839    |            |       |  0.04

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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.133000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.684351297909, Press = -1.10448049200005
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8423.1748   -8423.1748   -8498.8023   -8498.8023    292.68629    292.68629    23326.736    23326.736    3890.1591    3890.1591 
   78000   -8428.2523   -8428.2523   -8505.0984   -8505.0984     297.4022     297.4022    23351.938    23351.938    1235.0337    1235.0337 
Loop time of 149.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.513 hours/ns, 6.691 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.95     | 148.95     | 148.95     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092848   | 0.092848   | 0.092848   |   0.0 |  0.06
Output  | 0.0001433  | 0.0001433  | 0.0001433  |   0.0 |  0.00
Modify  | 0.34447    | 0.34447    | 0.34447    |   0.0 |  0.23
Other   |            | 0.0586     |            |       |  0.04

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:      128336.0 ave      128336 max      128336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128336
Ave neighs/atom = 64.168000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.684510965105, Press = -1.16525677427933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -8428.2523   -8428.2523   -8505.0984   -8505.0984     297.4022     297.4022    23351.938    23351.938    1235.0337    1235.0337 
   79000   -8425.4191   -8425.4191   -8500.5225   -8500.5225    290.65794    290.65794    23370.338    23370.338    518.98292    518.98292 
Loop time of 149.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.495 hours/ns, 6.694 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.88     | 148.88     | 148.88     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093264   | 0.093264   | 0.093264   |   0.0 |  0.06
Output  | 0.00015231 | 0.00015231 | 0.00015231 |   0.0 |  0.00
Modify  | 0.34513    | 0.34513    | 0.34513    |   0.0 |  0.23
Other   |            | 0.05871    |            |       |  0.04

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:      128292.0 ave      128292 max      128292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128292
Ave neighs/atom = 64.146000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.683408456283, Press = -0.950812287628618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -8425.4191   -8425.4191   -8500.5225   -8500.5225    290.65794    290.65794    23370.338    23370.338    518.98292    518.98292 
   80000   -8427.8848   -8427.8848   -8503.1474   -8503.1474    291.27386    291.27386    23367.385    23367.385    304.26435    304.26435 
Loop time of 149.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.610 hours/ns, 6.676 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.3      | 149.3      | 149.3      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092867   | 0.092867   | 0.092867   |   0.0 |  0.06
Output  | 0.00025192 | 0.00025192 | 0.00025192 |   0.0 |  0.00
Modify  | 0.34583    | 0.34583    | 0.34583    |   0.0 |  0.23
Other   |            | 0.05777    |            |       |  0.04

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:      128296.0 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.689574435011, Press = -1.21106910590616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -8427.8848   -8427.8848   -8503.1474   -8503.1474    291.27386    291.27386    23367.385    23367.385    304.26435    304.26435 
   81000   -8424.9641   -8424.9641   -8500.2815   -8500.2815    291.48644    291.48644    23379.388    23379.388   -51.666982   -51.666982 
Loop time of 149.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.535 hours/ns, 6.688 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.03     | 149.03     | 149.03     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092677   | 0.092677   | 0.092677   |   0.0 |  0.06
Output  | 0.00015592 | 0.00015592 | 0.00015592 |   0.0 |  0.00
Modify  | 0.34608    | 0.34608    | 0.34608    |   0.0 |  0.23
Other   |            | 0.05778    |            |       |  0.04

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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.671941464175, Press = -1.62123554594626
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -8424.9641   -8424.9641   -8500.2815   -8500.2815    291.48644    291.48644    23379.388    23379.388   -51.666982   -51.666982 
   82000    -8429.267    -8429.267   -8503.0242   -8503.0242    285.44798    285.44798    23403.899    23403.899   -2162.0451   -2162.0451 
Loop time of 149.596 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.555 hours/ns, 6.685 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.1      | 149.1      | 149.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091658   | 0.091658   | 0.091658   |   0.0 |  0.06
Output  | 0.00014743 | 0.00014743 | 0.00014743 |   0.0 |  0.00
Modify  | 0.34548    | 0.34548    | 0.34548    |   0.0 |  0.23
Other   |            | 0.05802    |            |       |  0.04

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:      128336.0 ave      128336 max      128336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128336
Ave neighs/atom = 64.168000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.66243781175, Press = -2.42290531473398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000    -8429.267    -8429.267   -8503.0242   -8503.0242    285.44798    285.44798    23403.899    23403.899   -2162.0451   -2162.0451 
   83000   -8425.1647   -8425.1647   -8499.2244   -8499.2244     286.6186     286.6186    23405.267    23405.267   -1648.6472   -1648.6472 
Loop time of 149.601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.556 hours/ns, 6.684 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.1      | 149.1      | 149.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092134   | 0.092134   | 0.092134   |   0.0 |  0.06
Output  | 0.00025253 | 0.00025253 | 0.00025253 |   0.0 |  0.00
Modify  | 0.34781    | 0.34781    | 0.34781    |   0.0 |  0.23
Other   |            | 0.05843    |            |       |  0.04

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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.640532538293, Press = -1.32347325296739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -8425.1647   -8425.1647   -8499.2244   -8499.2244     286.6186     286.6186    23405.267    23405.267   -1648.6472   -1648.6472 
   84000    -8425.393    -8425.393   -8501.4977   -8501.4977    294.53311    294.53311     23406.38     23406.38   -2027.7099   -2027.7099 
Loop time of 149.321 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.478 hours/ns, 6.697 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.82     | 148.82     | 148.82     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091986   | 0.091986   | 0.091986   |   0.0 |  0.06
Output  | 0.0001451  | 0.0001451  | 0.0001451  |   0.0 |  0.00
Modify  | 0.34672    | 0.34672    | 0.34672    |   0.0 |  0.23
Other   |            | 0.05817    |            |       |  0.04

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:      128246.0 ave      128246 max      128246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128246
Ave neighs/atom = 64.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.671552623536, Press = -0.938620436815806
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000    -8425.393    -8425.393   -8501.4977   -8501.4977    294.53311    294.53311     23406.38     23406.38   -2027.7099   -2027.7099 
   85000   -8424.8517   -8424.8517   -8502.4407   -8502.4407    300.27747    300.27747    23399.396    23399.396   -1659.3826   -1659.3826 
Loop time of 150.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.673 hours/ns, 6.666 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.52     | 149.52     | 149.52     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092921   | 0.092921   | 0.092921   |   0.0 |  0.06
Output  | 0.00014611 | 0.00014611 | 0.00014611 |   0.0 |  0.00
Modify  | 0.34947    | 0.34947    | 0.34947    |   0.0 |  0.23
Other   |            | 0.05814    |            |       |  0.04

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:      128246.0 ave      128246 max      128246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128246
Ave neighs/atom = 64.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.680878032909, Press = -0.557929278201732
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -8424.8517   -8424.8517   -8502.4407   -8502.4407    300.27747    300.27747    23399.396    23399.396   -1659.3826   -1659.3826 
   86000   -8424.8133   -8424.8133   -8501.4286   -8501.4286    296.50911    296.50911    23394.691    23394.691   -1174.0817   -1174.0817 
Loop time of 149.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.412 hours/ns, 6.708 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.59     | 148.59     | 148.59     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092495   | 0.092495   | 0.092495   |   0.0 |  0.06
Output  | 0.00025928 | 0.00025928 | 0.00025928 |   0.0 |  0.00
Modify  | 0.34571    | 0.34571    | 0.34571    |   0.0 |  0.23
Other   |            | 0.05845    |            |       |  0.04

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:      128226.0 ave      128226 max      128226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128226
Ave neighs/atom = 64.113000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.7118856502, Press = -0.583755971086901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8424.8133   -8424.8133   -8501.4286   -8501.4286    296.50911    296.50911    23394.691    23394.691   -1174.0817   -1174.0817 
   87000   -8424.3391   -8424.3391   -8499.1283   -8499.1283    289.44175    289.44175    23401.314    23401.314   -1455.0457   -1455.0457 
Loop time of 149.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.572 hours/ns, 6.682 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.16     | 149.16     | 149.16     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092821   | 0.092821   | 0.092821   |   0.0 |  0.06
Output  | 0.00015182 | 0.00015182 | 0.00015182 |   0.0 |  0.00
Modify  | 0.34807    | 0.34807    | 0.34807    |   0.0 |  0.23
Other   |            | 0.05752    |            |       |  0.04

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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.717307806866, Press = -0.403872843614705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8424.3391   -8424.3391   -8499.1283   -8499.1283    289.44175    289.44175    23401.314    23401.314   -1455.0457   -1455.0457 
   88000   -8423.6368   -8423.6368   -8502.1804   -8502.1804    303.97215    303.97215    23421.133    23421.133    -2901.365    -2901.365 
Loop time of 149.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.410 hours/ns, 6.708 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.58     | 148.58     | 148.58     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092647   | 0.092647   | 0.092647   |   0.0 |  0.06
Output  | 0.00014431 | 0.00014431 | 0.00014431 |   0.0 |  0.00
Modify  | 0.34647    | 0.34647    | 0.34647    |   0.0 |  0.23
Other   |            | 0.05833    |            |       |  0.04

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:      128278.0 ave      128278 max      128278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128278
Ave neighs/atom = 64.139000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.764697155405, Press = 0.0245256448201855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8423.6368   -8423.6368   -8502.1804   -8502.1804    303.97215    303.97215    23421.133    23421.133    -2901.365    -2901.365 
   89000   -8427.1938   -8427.1938   -8501.2789   -8501.2789    286.71712    286.71712    23407.346    23407.346   -2097.7903   -2097.7903 
Loop time of 148.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.372 hours/ns, 6.714 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.44     | 148.44     | 148.44     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091944   | 0.091944   | 0.091944   |   0.0 |  0.06
Output  | 0.00018816 | 0.00018816 | 0.00018816 |   0.0 |  0.00
Modify  | 0.34574    | 0.34574    | 0.34574    |   0.0 |  0.23
Other   |            | 0.05926    |            |       |  0.04

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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774629914216, Press = 0.535470239051692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8427.1938   -8427.1938   -8501.2789   -8501.2789    286.71712    286.71712    23407.346    23407.346   -2097.7903   -2097.7903 
   90000   -8421.7915   -8421.7915    -8500.302    -8500.302    303.84377    303.84377    23393.562    23393.562   -902.57913   -902.57913 
Loop time of 149.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.486 hours/ns, 6.696 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.85     | 148.85     | 148.85     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092343   | 0.092343   | 0.092343   |   0.0 |  0.06
Output  | 0.00014431 | 0.00014431 | 0.00014431 |   0.0 |  0.00
Modify  | 0.34532    | 0.34532    | 0.34532    |   0.0 |  0.23
Other   |            | 0.05849    |            |       |  0.04

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:      128318.0 ave      128318 max      128318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128318
Ave neighs/atom = 64.159000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813499280765, Press = 0.147140688347479
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8421.7915   -8421.7915    -8500.302    -8500.302    303.84377    303.84377    23393.562    23393.562   -902.57913   -902.57913 
   91000   -8425.9676   -8425.9676    -8501.608    -8501.608    292.73584    292.73584    23376.172    23376.172    84.921108    84.921108 
Loop time of 149.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.498 hours/ns, 6.694 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.9      | 148.9      | 148.9      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092426   | 0.092426   | 0.092426   |   0.0 |  0.06
Output  | 0.0001429  | 0.0001429  | 0.0001429  |   0.0 |  0.00
Modify  | 0.34613    | 0.34613    | 0.34613    |   0.0 |  0.23
Other   |            | 0.05825    |            |       |  0.04

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:      128326.0 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838655653809, Press = -0.0343006649629954
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -8425.9676   -8425.9676    -8501.608    -8501.608    292.73584    292.73584    23376.172    23376.172    84.921108    84.921108 
   92000   -8426.1133   -8426.1133   -8502.0499   -8502.0499    293.88267    293.88267    23362.346    23362.346    1114.0328    1114.0328 
Loop time of 149.113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.420 hours/ns, 6.706 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.62     | 148.62     | 148.62     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092637   | 0.092637   | 0.092637   |   0.0 |  0.06
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.34542    | 0.34542    | 0.34542    |   0.0 |  0.23
Other   |            | 0.05833    |            |       |  0.04

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:      128308.0 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.86846510233, Press = -0.0665028656274954
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -8426.1133   -8426.1133   -8502.0499   -8502.0499    293.88267    293.88267    23362.346    23362.346    1114.0328    1114.0328 
   93000   -8424.9308   -8424.9308   -8501.3935   -8501.3935    295.91852    295.91852    23352.396    23352.396    1788.0316    1788.0316 
Loop time of 149.596 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.555 hours/ns, 6.685 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.1      | 149.1      | 149.1      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092809   | 0.092809   | 0.092809   |   0.0 |  0.06
Output  | 0.0001515  | 0.0001515  | 0.0001515  |   0.0 |  0.00
Modify  | 0.34571    | 0.34571    | 0.34571    |   0.0 |  0.23
Other   |            | 0.05758    |            |       |  0.04

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:      128282.0 ave      128282 max      128282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128282
Ave neighs/atom = 64.141000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.849181763053, Press = -0.19168614481995
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -8424.9308   -8424.9308   -8501.3935   -8501.3935    295.91852    295.91852    23352.396    23352.396    1788.0316    1788.0316 
   94000   -8430.1579   -8430.1579   -8503.4461   -8503.4461    283.63262    283.63262    23336.865    23336.865    2444.6978    2444.6978 
Loop time of 149.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.528 hours/ns, 6.689 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        | 149        | 149        |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092423   | 0.092423   | 0.092423   |   0.0 |  0.06
Output  | 0.00014499 | 0.00014499 | 0.00014499 |   0.0 |  0.00
Modify  | 0.34593    | 0.34593    | 0.34593    |   0.0 |  0.23
Other   |            | 0.05882    |            |       |  0.04

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:      128308.0 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.839085785908, Press = -0.393841753490865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -8430.1579   -8430.1579   -8503.4461   -8503.4461    283.63262    283.63262    23336.865    23336.865    2444.6978    2444.6978 
   95000     -8425.09     -8425.09   -8500.7566   -8500.7566    292.83772    292.83772    23336.071    23336.071    3003.1433    3003.1433 
Loop time of 149.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.470 hours/ns, 6.698 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.8      | 148.8      | 148.8      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092589   | 0.092589   | 0.092589   |   0.0 |  0.06
Output  | 0.00014437 | 0.00014437 | 0.00014437 |   0.0 |  0.00
Modify  | 0.34535    | 0.34535    | 0.34535    |   0.0 |  0.23
Other   |            | 0.05848    |            |       |  0.04

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:      128262.0 ave      128262 max      128262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128262
Ave neighs/atom = 64.131000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811423322978, Press = -0.514123922502528
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000     -8425.09     -8425.09   -8500.7566   -8500.7566    292.83772    292.83772    23336.071    23336.071    3003.1433    3003.1433 
   96000   -8426.9149   -8426.9149   -8502.3961   -8502.3961    292.11993    292.11993    23336.695    23336.695    2667.2728    2667.2728 
Loop time of 151.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.109 hours/ns, 6.597 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    | 151.09     | 151.09     | 151.09     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093587   | 0.093587   | 0.093587   |   0.0 |  0.06
Output  | 0.00015272 | 0.00015272 | 0.00015272 |   0.0 |  0.00
Modify  | 0.35162    | 0.35162    | 0.35162    |   0.0 |  0.23
Other   |            | 0.05937    |            |       |  0.04

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:      128366.0 ave      128366 max      128366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128366
Ave neighs/atom = 64.183000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.823790529313, Press = -0.920490178437149
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -8426.9149   -8426.9149   -8502.3961   -8502.3961    292.11993    292.11993    23336.695    23336.695    2667.2728    2667.2728 
   97000   -8423.5028   -8423.5028   -8499.0245   -8499.0245    292.27683    292.27683    23367.024    23367.024    1106.3308    1106.3308 
Loop time of 149.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.481 hours/ns, 6.697 timesteps/s
100.1% 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.83     | 148.83     | 148.83     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092382   | 0.092382   | 0.092382   |   0.0 |  0.06
Output  | 0.00014674 | 0.00014674 | 0.00014674 |   0.0 |  0.00
Modify  | 0.34511    | 0.34511    | 0.34511    |   0.0 |  0.23
Other   |            | 0.05885    |            |       |  0.04

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:      128318.0 ave      128318 max      128318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128318
Ave neighs/atom = 64.159000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813367707112, Press = -0.688794797776799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -8423.5028   -8423.5028   -8499.0245   -8499.0245    292.27683    292.27683    23367.024    23367.024    1106.3308    1106.3308 
   98000     -8426.65     -8426.65    -8503.622    -8503.622    297.88947    297.88947    23371.066    23371.066    250.19973    250.19973 
Loop time of 149.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.505 hours/ns, 6.693 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.92     | 148.92     | 148.92     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093229   | 0.093229   | 0.093229   |   0.0 |  0.06
Output  | 0.00014716 | 0.00014716 | 0.00014716 |   0.0 |  0.00
Modify  | 0.3465     | 0.3465     | 0.3465     |   0.0 |  0.23
Other   |            | 0.05865    |            |       |  0.04

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:      128292.0 ave      128292 max      128292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128292
Ave neighs/atom = 64.146000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84361056738, Press = -0.790834887715438
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000     -8426.65     -8426.65    -8503.622    -8503.622    297.88947    297.88947    23371.066    23371.066    250.19973    250.19973 
   99000   -8425.3734   -8425.3734   -8499.8207   -8499.8207    288.11878    288.11878    23376.485    23376.485    271.55166    271.55166 
Loop time of 149.214 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.448 hours/ns, 6.702 timesteps/s
100.1% 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.72     | 148.72     | 148.72     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09272    | 0.09272    | 0.09272    |   0.0 |  0.06
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.3459     | 0.3459     | 0.3459     |   0.0 |  0.23
Other   |            | 0.05904    |            |       |  0.04

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:      128260.0 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.860945480941, Press = -0.667510434783123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -8425.3734   -8425.3734   -8499.8207   -8499.8207    288.11878    288.11878    23376.485    23376.485    271.55166    271.55166 
  100000   -8424.2913   -8424.2913   -8499.9436   -8499.9436    292.78231    292.78231    23389.059    23389.059    -587.1622    -587.1622 
Loop time of 149.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.566 hours/ns, 6.683 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.14     | 149.14     | 149.14     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092604   | 0.092604   | 0.092604   |   0.0 |  0.06
Output  | 0.00025905 | 0.00025905 | 0.00025905 |   0.0 |  0.00
Modify  | 0.34619    | 0.34619    | 0.34619    |   0.0 |  0.23
Other   |            | 0.05861    |            |       |  0.04

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:      128316.0 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128316
Ave neighs/atom = 64.158000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.876191707061, Press = -0.71799517878992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -8424.2913   -8424.2913   -8499.9436   -8499.9436    292.78231    292.78231    23389.059    23389.059    -587.1622    -587.1622 
  101000   -8426.4617   -8426.4617   -8501.2189   -8501.2189    289.31818    289.31818    23406.966    23406.966   -2035.5405   -2035.5405 
Loop time of 149.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.559 hours/ns, 6.684 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.12     | 149.12     | 149.12     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092373   | 0.092373   | 0.092373   |   0.0 |  0.06
Output  | 0.00019343 | 0.00019343 | 0.00019343 |   0.0 |  0.00
Modify  | 0.34527    | 0.34527    | 0.34527    |   0.0 |  0.23
Other   |            | 0.05909    |            |       |  0.04

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:      128294.0 ave      128294 max      128294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128294
Ave neighs/atom = 64.147000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.868891180367, Press = -0.925240369966065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -8426.4617   -8426.4617   -8501.2189   -8501.2189    289.31818    289.31818    23406.966    23406.966   -2035.5405   -2035.5405 
  102000    -8422.322    -8422.322   -8500.1679   -8500.1679    301.27192    301.27192    23425.335    23425.335    -3042.498    -3042.498 
Loop time of 149.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.423 hours/ns, 6.706 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.63     | 148.63     | 148.63     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092818   | 0.092818   | 0.092818   |   0.0 |  0.06
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.34619    | 0.34619    | 0.34619    |   0.0 |  0.23
Other   |            | 0.05896    |            |       |  0.04

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:      128214.0 ave      128214 max      128214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128214
Ave neighs/atom = 64.107000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.895372225795, Press = -0.874613096123947
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000    -8422.322    -8422.322   -8500.1679   -8500.1679    301.27192    301.27192    23425.335    23425.335    -3042.498    -3042.498 
  103000   -8427.9012   -8427.9012   -8501.7423   -8501.7423    285.77255    285.77255    23410.989    23410.989   -2409.2164   -2409.2164 
Loop time of 149.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.454 hours/ns, 6.701 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.73     | 148.73     | 148.73     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092566   | 0.092566   | 0.092566   |   0.0 |  0.06
Output  | 0.00014604 | 0.00014604 | 0.00014604 |   0.0 |  0.00
Modify  | 0.34723    | 0.34723    | 0.34723    |   0.0 |  0.23
Other   |            | 0.0587     |            |       |  0.04

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:      128238.0 ave      128238 max      128238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128238
Ave neighs/atom = 64.119000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903968823509, Press = -0.529859591166613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -8427.9012   -8427.9012   -8501.7423   -8501.7423    285.77255    285.77255    23410.989    23410.989   -2409.2164   -2409.2164 
  104000   -8423.3318   -8423.3318   -8498.3223   -8498.3223    290.22108    290.22108    23399.968    23399.968   -1131.1853   -1131.1853 
Loop time of 151.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.572 ns/day, 41.956 hours/ns, 6.621 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    | 150.54     | 150.54     | 150.54     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0938     | 0.0938     | 0.0938     |   0.0 |  0.06
Output  | 0.00015305 | 0.00015305 | 0.00015305 |   0.0 |  0.00
Modify  | 0.3499     | 0.3499     | 0.3499     |   0.0 |  0.23
Other   |            | 0.05816    |            |       |  0.04

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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903939954785, Press = -0.309541997144311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -8423.3318   -8423.3318   -8498.3223   -8498.3223    290.22108    290.22108    23399.968    23399.968   -1131.1853   -1131.1853 
  105000   -8427.1534   -8427.1534   -8501.9265   -8501.9265    289.37951    289.37951    23385.015    23385.015   -649.96897   -649.96897 
Loop time of 150.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.804 hours/ns, 6.645 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.99     | 149.99     | 149.99     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092789   | 0.092789   | 0.092789   |   0.0 |  0.06
Output  | 0.00014436 | 0.00014436 | 0.00014436 |   0.0 |  0.00
Modify  | 0.34981    | 0.34981    | 0.34981    |   0.0 |  0.23
Other   |            | 0.05812    |            |       |  0.04

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:      128284.0 ave      128284 max      128284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128284
Ave neighs/atom = 64.142000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921142661144, Press = -0.337285517050374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -8427.1534   -8427.1534   -8501.9265   -8501.9265    289.37951    289.37951    23385.015    23385.015   -649.96897   -649.96897 
  106000    -8423.326    -8423.326   -8500.2955   -8500.2955    297.87993    297.87993    23387.406    23387.406   -526.08721   -526.08721 
Loop time of 149.9 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.639 hours/ns, 6.671 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.4      | 149.4      | 149.4      |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093454   | 0.093454   | 0.093454   |   0.0 |  0.06
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.34592    | 0.34592    | 0.34592    |   0.0 |  0.23
Other   |            | 0.05851    |            |       |  0.04

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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945698496157, Press = -0.224251006763526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000    -8423.326    -8423.326   -8500.2955   -8500.2955    297.87993    297.87993    23387.406    23387.406   -526.08721   -526.08721 
  107000   -8427.6584   -8427.6584   -8501.4379   -8501.4379    285.53445    285.53445    23375.202    23375.202   -6.3138709   -6.3138709 
Loop time of 149.408 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.502 hours/ns, 6.693 timesteps/s
100.1% 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.91     | 148.91     | 148.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092364   | 0.092364   | 0.092364   |   0.0 |  0.06
Output  | 0.00014475 | 0.00014475 | 0.00014475 |   0.0 |  0.00
Modify  | 0.34835    | 0.34835    | 0.34835    |   0.0 |  0.23
Other   |            | 0.05846    |            |       |  0.04

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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0