# 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.866965785622597*${_u_distance}
variable latticeconst_converted equal 2.866965785622597*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.8669657856226
Lattice spacing in x,y,z = 2.8669658 2.8669658 2.8669658
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.669658 28.669658 28.669658)
  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.669658 28.669658 28.669658)
  create_atoms CPU = 0.007 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 EAM_Dynamo_BonnyTerentyevPasianot_2011_FeNiCr__MO_677715648236_000
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 23565.0046784438    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23565.0046784438/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23565.0046784438/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23565.0046784438/(1*1*${_u_distance})
variable      V0_metal equal 23565.0046784438/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23565.0046784438*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23565.0046784438 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_677715648236_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7922.9895   -7922.9895   -8009.0725   -8009.0725       333.15       333.15    23565.005    23565.005    3901.8396    3901.8396 
    1000   -7970.6173   -7970.6173   -8054.4332   -8054.4332    324.37636    324.37636    21739.689    21739.689   -1299.8569   -1299.8569 
Loop time of 32.0913 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.914 hours/ns, 31.161 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.389     | 31.389     | 31.389     |   0.0 | 97.81
Neigh   | 0.14238    | 0.14238    | 0.14238    |   0.0 |  0.44
Comm    | 0.1331     | 0.1331     | 0.1331     |   0.0 |  0.41
Output  | 0.00019871 | 0.00019871 | 0.00019871 |   0.0 |  0.00
Modify  | 0.3611     | 0.3611     | 0.3611     |   0.0 |  1.13
Other   |            | 0.06527    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331968.0 ave      331968 max      331968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331968
Ave neighs/atom = 165.98400
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7970.6173   -7970.6173   -8054.4332   -8054.4332    324.37636    324.37636    21739.689    21739.689   -1299.8569   -1299.8569 
    2000   -7994.0371   -7994.0371   -8082.9196   -8082.9196    343.98455    343.98455    21689.867    21689.867    2304.3131    2304.3131 
Loop time of 31.6829 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.801 hours/ns, 31.563 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.955     | 30.955     | 30.955     |   0.0 | 97.70
Neigh   | 0.19012    | 0.19012    | 0.19012    |   0.0 |  0.60
Comm    | 0.12549    | 0.12549    | 0.12549    |   0.0 |  0.40
Output  | 0.00019042 | 0.00019042 | 0.00019042 |   0.0 |  0.00
Modify  | 0.3479     | 0.3479     | 0.3479     |   0.0 |  1.10
Other   |            | 0.06426    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331014.0 ave      331014 max      331014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331014
Ave neighs/atom = 165.50700
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7994.0371   -7994.0371   -8082.9196   -8082.9196    343.98455    343.98455    21689.867    21689.867    2304.3131    2304.3131 
    3000   -8000.9618   -8000.9618   -8085.9227   -8085.9227     328.8074     328.8074    21666.766    21666.766    1210.8036    1210.8036 
Loop time of 32.3131 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.976 hours/ns, 30.947 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    | 31.765     | 31.765     | 31.765     |   0.0 | 98.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12624    | 0.12624    | 0.12624    |   0.0 |  0.39
Output  | 0.00018626 | 0.00018626 | 0.00018626 |   0.0 |  0.00
Modify  | 0.35641    | 0.35641    | 0.35641    |   0.0 |  1.10
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331028.0 ave      331028 max      331028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 2.630 ns/day, 9.125 hours/ns, 30.440 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.295     | 32.295     | 32.295     |   0.0 | 98.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1271     | 0.1271     | 0.1271     |   0.0 |  0.39
Output  | 0.00019485 | 0.00019485 | 0.00019485 |   0.0 |  0.00
Modify  | 0.36262    | 0.36262    | 0.36262    |   0.0 |  1.10
Other   |            | 0.06666    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330964.0 ave      330964 max      330964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 2.722 ns/day, 8.816 hours/ns, 31.507 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    | 31.199     | 31.199     | 31.199     |   0.0 | 98.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.39
Output  | 0.00014923 | 0.00014923 | 0.00014923 |   0.0 |  0.00
Modify  | 0.35211    | 0.35211    | 0.35211    |   0.0 |  1.11
Other   |            | 0.0659     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331062.0 ave      331062 max      331062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331062
Ave neighs/atom = 165.53100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.163281353241, Press = -745.947904762131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8004.3099   -8004.3099   -8088.7209   -8088.7209    326.67935    326.67935    21763.659    21763.659   -3749.7298   -3749.7298 
    6000   -8003.7825   -8003.7825    -8091.454    -8091.454     339.2976     339.2976    21678.742    21678.742   -630.74429   -630.74429 
Loop time of 31.943 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.873 hours/ns, 31.306 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    | 31.379     | 31.379     | 31.379     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12465    | 0.12465    | 0.12465    |   0.0 |  0.39
Output  | 0.00015202 | 0.00015202 | 0.00015202 |   0.0 |  0.00
Modify  | 0.37292    | 0.37292    | 0.37292    |   0.0 |  1.17
Other   |            | 0.06578    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330066.0 ave      330066 max      330066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330066
Ave neighs/atom = 165.03300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.208074519528, Press = -15.6459776692579
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8003.7825   -8003.7825    -8091.454    -8091.454     339.2976     339.2976    21678.742    21678.742   -630.74429   -630.74429 
    7000   -8008.0122   -8008.0122   -8092.5188   -8092.5188    327.04954    327.04954    21678.855    21678.855   -631.76902   -631.76902 
Loop time of 32.471 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.020 hours/ns, 30.797 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.9       | 31.9       | 31.9       |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12663    | 0.12663    | 0.12663    |   0.0 |  0.39
Output  | 0.00015212 | 0.00015212 | 0.00015212 |   0.0 |  0.00
Modify  | 0.37843    | 0.37843    | 0.37843    |   0.0 |  1.17
Other   |            | 0.06605    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331282.0 ave      331282 max      331282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331282
Ave neighs/atom = 165.64100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.602523878747, Press = -1.78827153392813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8008.0122   -8008.0122   -8092.5188   -8092.5188    327.04954    327.04954    21678.855    21678.855   -631.76902   -631.76902 
    8000   -8003.1645   -8003.1645   -8089.8906   -8089.8906    335.63863    335.63863    21719.539    21719.539   -1781.7555   -1781.7555 
Loop time of 31.3643 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.883 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.811     | 30.811     | 30.811     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12389    | 0.12389    | 0.12389    |   0.0 |  0.40
Output  | 0.00020822 | 0.00020822 | 0.00020822 |   0.0 |  0.00
Modify  | 0.36433    | 0.36433    | 0.36433    |   0.0 |  1.16
Other   |            | 0.0653     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331254.0 ave      331254 max      331254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331254
Ave neighs/atom = 165.62700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.557519999684, Press = -4.58360147549483
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8003.1645   -8003.1645   -8089.8906   -8089.8906    335.63863    335.63863    21719.539    21719.539   -1781.7555   -1781.7555 
    9000   -8007.8631   -8007.8631   -8092.2563   -8092.2563    326.61042    326.61042    21665.872    21665.872       546.82       546.82 
Loop time of 32.2251 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.951 hours/ns, 31.032 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.658     | 31.658     | 31.658     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12647    | 0.12647    | 0.12647    |   0.0 |  0.39
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.37481    | 0.37481    | 0.37481    |   0.0 |  1.16
Other   |            | 0.06603    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330516.0 ave      330516 max      330516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330516
Ave neighs/atom = 165.25800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.926870953586, Press = -16.2885407287237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8007.8631   -8007.8631   -8092.2563   -8092.2563    326.61042    326.61042    21665.872    21665.872       546.82       546.82 
   10000   -8002.9185   -8002.9185   -8088.7826   -8088.7826    332.30292    332.30292        21691        21691    27.022472    27.022472 
Loop time of 32.6554 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.646 ns/day, 9.071 hours/ns, 30.623 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    | 32.083     | 32.083     | 32.083     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12568    | 0.12568    | 0.12568    |   0.0 |  0.38
Output  | 0.00015047 | 0.00015047 | 0.00015047 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  1.17
Other   |            | 0.0655     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5391.00 ave        5391 max        5391 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331290.0 ave      331290 max      331290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331290
Ave neighs/atom = 165.64500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.851113106017, Press = -3.06649188232192
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8002.9185   -8002.9185   -8088.7826   -8088.7826    332.30292    332.30292        21691        21691    27.022472    27.022472 
   11000    -8007.109    -8007.109   -8092.0959   -8092.0959    328.90805    328.90805    21663.407    21663.407    1437.3852    1437.3852 
Loop time of 32.8584 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.127 hours/ns, 30.434 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    | 32.286     | 32.286     | 32.286     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12665    | 0.12665    | 0.12665    |   0.0 |  0.39
Output  | 0.00015978 | 0.00015978 | 0.00015978 |   0.0 |  0.00
Modify  | 0.37961    | 0.37961    | 0.37961    |   0.0 |  1.16
Other   |            | 0.06575    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331060.0 ave      331060 max      331060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331060
Ave neighs/atom = 165.53000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.871201867554, Press = -10.5988358841943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000    -8007.109    -8007.109   -8092.0959   -8092.0959    328.90805    328.90805    21663.407    21663.407    1437.3852    1437.3852 
   12000   -8006.3676   -8006.3676   -8090.4249   -8090.4249    325.31061    325.31061    21704.464    21704.464    -389.8025    -389.8025 
Loop time of 33.4166 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.586 ns/day, 9.282 hours/ns, 29.925 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.839     | 32.839     | 32.839     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12743    | 0.12743    | 0.12743    |   0.0 |  0.38
Output  | 0.0001561  | 0.0001561  | 0.0001561  |   0.0 |  0.00
Modify  | 0.384      | 0.384      | 0.384      |   0.0 |  1.15
Other   |            | 0.06589    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331692.0 ave      331692 max      331692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331692
Ave neighs/atom = 165.84600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.050384317728, Press = -12.3083018811034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8006.3676   -8006.3676   -8090.4249   -8090.4249    325.31061    325.31061    21704.464    21704.464    -389.8025    -389.8025 
   13000   -8001.1448   -8001.1448   -8088.5673   -8088.5673    338.33437    338.33437    21666.043    21666.043    2436.2055    2436.2055 
Loop time of 32.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.005 hours/ns, 30.847 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    | 31.849     | 31.849     | 31.849     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1255     | 0.1255     | 0.1255     |   0.0 |  0.39
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.37744    | 0.37744    | 0.37744    |   0.0 |  1.16
Other   |            | 0.0657     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330658.0 ave      330658 max      330658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330658
Ave neighs/atom = 165.32900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.983574862655, Press = -5.16991329364403
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8001.1448   -8001.1448   -8088.5673   -8088.5673    338.33437    338.33437    21666.043    21666.043    2436.2055    2436.2055 
   14000    -8005.506    -8005.506   -8093.1983   -8093.1983    339.37837    339.37837     21693.42     21693.42   -1043.3826   -1043.3826 
Loop time of 32.3039 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.973 hours/ns, 30.956 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    | 31.737     | 31.737     | 31.737     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.39
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.37587    | 0.37587    | 0.37587    |   0.0 |  1.16
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331478.0 ave      331478 max      331478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331478
Ave neighs/atom = 165.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.253319086405, Press = -4.58542173659198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -8005.506    -8005.506   -8093.1983   -8093.1983    339.37837    339.37837     21693.42     21693.42   -1043.3826   -1043.3826 
   15000    -8003.155    -8003.155   -8088.9419   -8088.9419    332.00404    332.00404    21695.622    21695.622   -8.8698533   -8.8698533 
Loop time of 32.0449 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.696 ns/day, 8.901 hours/ns, 31.206 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.474     | 31.474     | 31.474     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1267     | 0.1267     | 0.1267     |   0.0 |  0.40
Output  | 0.00016956 | 0.00016956 | 0.00016956 |   0.0 |  0.00
Modify  | 0.37847    | 0.37847    | 0.37847    |   0.0 |  1.18
Other   |            | 0.06591    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330830.0 ave      330830 max      330830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330830
Ave neighs/atom = 165.41500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.380414686285, Press = 1.60080578290112
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -8003.155    -8003.155   -8088.9419   -8088.9419    332.00404    332.00404    21695.622    21695.622   -8.8698533   -8.8698533 
   16000   -8005.9698   -8005.9698   -8090.4284   -8090.4284     326.8633     326.8633    21693.797    21693.797     344.5387     344.5387 
Loop time of 32.5815 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.652 ns/day, 9.050 hours/ns, 30.692 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.011     | 32.011     | 32.011     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1258     | 0.1258     | 0.1258     |   0.0 |  0.39
Output  | 0.00014807 | 0.00014807 | 0.00014807 |   0.0 |  0.00
Modify  | 0.37879    | 0.37879    | 0.37879    |   0.0 |  1.16
Other   |            | 0.06546    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331204.0 ave      331204 max      331204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331204
Ave neighs/atom = 165.60200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.325941753296, Press = -9.61605635628872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8005.9698   -8005.9698   -8090.4284   -8090.4284     326.8633     326.8633    21693.797    21693.797     344.5387     344.5387 
   17000   -8003.4599   -8003.4599   -8090.4811   -8090.4811    336.78119    336.78119    21686.253    21686.253    372.51711    372.51711 
Loop time of 32.8097 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.114 hours/ns, 30.479 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.238     | 32.238     | 32.238     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12589    | 0.12589    | 0.12589    |   0.0 |  0.38
Output  | 0.00019468 | 0.00019468 | 0.00019468 |   0.0 |  0.00
Modify  | 0.37998    | 0.37998    | 0.37998    |   0.0 |  1.16
Other   |            | 0.06546    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5385.00 ave        5385 max        5385 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330748.0 ave      330748 max      330748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330748
Ave neighs/atom = 165.37400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.293863588956, Press = -10.8441784510218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8003.4599   -8003.4599   -8090.4811   -8090.4811    336.78119    336.78119    21686.253    21686.253    372.51711    372.51711 
   18000   -7999.4405   -7999.4405   -8089.3726   -8089.3726    348.04656    348.04656    21709.807    21709.807    -1214.631    -1214.631 
Loop time of 32.4676 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.019 hours/ns, 30.800 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.902     | 31.902     | 31.902     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12517    | 0.12517    | 0.12517    |   0.0 |  0.39
Output  | 0.00015179 | 0.00015179 | 0.00015179 |   0.0 |  0.00
Modify  | 0.37493    | 0.37493    | 0.37493    |   0.0 |  1.15
Other   |            | 0.06533    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5400.00 ave        5400 max        5400 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331102.0 ave      331102 max      331102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331102
Ave neighs/atom = 165.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.394790845332, Press = -5.98911166428079
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7999.4405   -7999.4405   -8089.3726   -8089.3726    348.04656    348.04656    21709.807    21709.807    -1214.631    -1214.631 
   19000   -8002.8507   -8002.8507   -8089.9722   -8089.9722    337.16929    337.16929    21637.785    21637.785    2905.0033    2905.0033 
Loop time of 31.6859 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.802 hours/ns, 31.560 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.126     | 31.126     | 31.126     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12477    | 0.12477    | 0.12477    |   0.0 |  0.39
Output  | 0.00015197 | 0.00015197 | 0.00015197 |   0.0 |  0.00
Modify  | 0.3689     | 0.3689     | 0.3689     |   0.0 |  1.16
Other   |            | 0.06577    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330722.0 ave      330722 max      330722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330722
Ave neighs/atom = 165.36100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.590928116195, Press = -5.9240666807003
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8002.8507   -8002.8507   -8089.9722   -8089.9722    337.16929    337.16929    21637.785    21637.785    2905.0033    2905.0033 
   20000    -8005.493    -8005.493   -8094.4506   -8094.4506    344.27487    344.27487    21666.739    21666.739   -45.311269   -45.311269 
Loop time of 32.323 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.979 hours/ns, 30.938 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    | 31.758     | 31.758     | 31.758     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12453    | 0.12453    | 0.12453    |   0.0 |  0.39
Output  | 0.00019622 | 0.00019622 | 0.00019622 |   0.0 |  0.00
Modify  | 0.37406    | 0.37406    | 0.37406    |   0.0 |  1.16
Other   |            | 0.06582    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331814.0 ave      331814 max      331814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331814
Ave neighs/atom = 165.90700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.487540776585, Press = -5.594016334226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -8005.493    -8005.493   -8094.4506   -8094.4506    344.27487    344.27487    21666.739    21666.739   -45.311269   -45.311269 
   21000   -8007.8806   -8007.8806   -8090.1039   -8090.1039    318.21244    318.21244    21671.488    21671.488    893.33017    893.33017 
Loop time of 32.0085 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.891 hours/ns, 31.242 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    | 31.443     | 31.443     | 31.443     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12452    | 0.12452    | 0.12452    |   0.0 |  0.39
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.375      | 0.375      | 0.375      |   0.0 |  1.17
Other   |            | 0.0661     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5387.00 ave        5387 max        5387 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331532.0 ave      331532 max      331532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331532
Ave neighs/atom = 165.76600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.442350640608, Press = -6.85946958484034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8007.8806   -8007.8806   -8090.1039   -8090.1039    318.21244    318.21244    21671.488    21671.488    893.33017    893.33017 
   22000   -8001.1826   -8001.1826   -8088.6964   -8088.6964    338.68743    338.68743    21720.603    21720.603   -1028.2347   -1028.2347 
Loop time of 32.2306 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.953 hours/ns, 31.026 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    | 31.669     | 31.669     | 31.669     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12308    | 0.12308    | 0.12308    |   0.0 |  0.38
Output  | 0.00015159 | 0.00015159 | 0.00015159 |   0.0 |  0.00
Modify  | 0.37298    | 0.37298    | 0.37298    |   0.0 |  1.16
Other   |            | 0.06552    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5400.00 ave        5400 max        5400 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331336.0 ave      331336 max      331336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331336
Ave neighs/atom = 165.66800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.456308364298, Press = -2.82945640937191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8001.1826   -8001.1826   -8088.6964   -8088.6964    338.68743    338.68743    21720.603    21720.603   -1028.2347   -1028.2347 
   23000   -8003.0218   -8003.0218    -8090.662    -8090.662    339.17668    339.17668    21731.173    21731.173   -1105.9591   -1105.9591 
Loop time of 33.1575 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.606 ns/day, 9.210 hours/ns, 30.159 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    | 32.574     | 32.574     | 32.574     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1275     | 0.1275     | 0.1275     |   0.0 |  0.38
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.38976    | 0.38976    | 0.38976    |   0.0 |  1.18
Other   |            | 0.06622    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330750.0 ave      330750 max      330750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330750
Ave neighs/atom = 165.37500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.51969291286, Press = -0.991051673553555
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8003.0218   -8003.0218    -8090.662    -8090.662    339.17668    339.17668    21731.173    21731.173   -1105.9591   -1105.9591 
   24000   -8005.2334   -8005.2334   -8091.5865   -8091.5865    334.19547    334.19547    21659.301    21659.301    1173.5296    1173.5296 
Loop time of 34.4207 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.510 ns/day, 9.561 hours/ns, 29.052 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    | 33.827     | 33.827     | 33.827     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13014    | 0.13014    | 0.13014    |   0.0 |  0.38
Output  | 0.00019573 | 0.00019573 | 0.00019573 |   0.0 |  0.00
Modify  | 0.39748    | 0.39748    | 0.39748    |   0.0 |  1.15
Other   |            | 0.06631    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330438.0 ave      330438 max      330438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330438
Ave neighs/atom = 165.21900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.603689360575, Press = -1.8279712791982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8005.2334   -8005.2334   -8091.5865   -8091.5865    334.19547    334.19547    21659.301    21659.301    1173.5296    1173.5296 
   25000   -8000.9457   -8000.9457   -8091.9279   -8091.9279    352.11056    352.11056    21736.667    21736.667   -3274.0482   -3274.0482 
Loop time of 32.4884 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.659 ns/day, 9.025 hours/ns, 30.780 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    | 31.919     | 31.919     | 31.919     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.39
Output  | 0.0001941  | 0.0001941  | 0.0001941  |   0.0 |  0.00
Modify  | 0.37822    | 0.37822    | 0.37822    |   0.0 |  1.16
Other   |            | 0.06568    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331590.0 ave      331590 max      331590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331590
Ave neighs/atom = 165.79500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.613818459836, Press = 1.10137088084909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8000.9457   -8000.9457   -8091.9279   -8091.9279    352.11056    352.11056    21736.667    21736.667   -3274.0482   -3274.0482 
   26000   -8006.0372   -8006.0372   -8093.2583   -8093.2583     337.5545     337.5545    21655.161    21655.161    1493.2773    1493.2773 
Loop time of 33.0142 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.617 ns/day, 9.171 hours/ns, 30.290 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    | 32.438     | 32.438     | 32.438     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1266     | 0.1266     | 0.1266     |   0.0 |  0.38
Output  | 0.00015217 | 0.00015217 | 0.00015217 |   0.0 |  0.00
Modify  | 0.38336    | 0.38336    | 0.38336    |   0.0 |  1.16
Other   |            | 0.06602    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5395.00 ave        5395 max        5395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330346.0 ave      330346 max      330346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330346
Ave neighs/atom = 165.17300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.698965055355, Press = -0.613676486172339
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8006.0372   -8006.0372   -8093.2583   -8093.2583     337.5545     337.5545    21655.161    21655.161    1493.2773    1493.2773 
   27000   -8007.9784   -8007.9784   -8093.1699   -8093.1699    329.70012    329.70012    21638.499    21638.499    3555.4218    3555.4218 
Loop time of 31.1907 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.770 ns/day, 8.664 hours/ns, 32.061 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.64      | 30.64      | 30.64      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.39
Output  | 0.00015432 | 0.00015432 | 0.00015432 |   0.0 |  0.00
Modify  | 0.36245    | 0.36245    | 0.36245    |   0.0 |  1.16
Other   |            | 0.06542    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331536.0 ave      331536 max      331536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331536
Ave neighs/atom = 165.76800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.66216821871, Press = 0.232034721360528
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8007.9784   -8007.9784   -8093.1699   -8093.1699    329.70012    329.70012    21638.499    21638.499    3555.4218    3555.4218 
   28000   -8003.5298   -8003.5298   -8089.4976   -8089.4976     332.7041     332.7041    21708.775    21708.775   -310.58824   -310.58824 
Loop time of 33.4197 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.585 ns/day, 9.283 hours/ns, 29.922 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    | 32.837     | 32.837     | 32.837     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.38
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.38827    | 0.38827    | 0.38827    |   0.0 |  1.16
Other   |            | 0.06573    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5400.00 ave        5400 max        5400 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331988.0 ave      331988 max      331988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331988
Ave neighs/atom = 165.99400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.475662116346, Press = -5.28130059802884
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8003.5298   -8003.5298   -8089.4976   -8089.4976     332.7041     332.7041    21708.775    21708.775   -310.58824   -310.58824 
   29000   -8006.7563   -8006.7563   -8091.4676   -8091.4676    327.84151    327.84151    21635.002    21635.002    2810.7829    2810.7829 
Loop time of 33.3769 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.589 ns/day, 9.271 hours/ns, 29.961 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    | 32.792     | 32.792     | 32.792     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12857    | 0.12857    | 0.12857    |   0.0 |  0.39
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.39062    | 0.39062    | 0.39062    |   0.0 |  1.17
Other   |            | 0.06533    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330756.0 ave      330756 max      330756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330756
Ave neighs/atom = 165.37800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.405275447521, Press = -0.41590179059318
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8006.7563   -8006.7563   -8091.4676   -8091.4676    327.84151    327.84151    21635.002    21635.002    2810.7829    2810.7829 
   30000   -8002.3396   -8002.3396   -8090.3698   -8090.3698    340.68611    340.68611     21721.78     21721.78   -586.47007   -586.47007 
Loop time of 32.2314 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.953 hours/ns, 31.026 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    | 31.664     | 31.664     | 31.664     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12611    | 0.12611    | 0.12611    |   0.0 |  0.39
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.37577    | 0.37577    | 0.37577    |   0.0 |  1.17
Other   |            | 0.06562    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331768.0 ave      331768 max      331768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331768
Ave neighs/atom = 165.88400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.371775890072, Press = -1.45776516491969
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8002.3396   -8002.3396   -8090.3698   -8090.3698    340.68611    340.68611     21721.78     21721.78   -586.47007   -586.47007 
   31000   -8007.0167   -8007.0167   -8092.4835   -8092.4835    330.76569    330.76569    21654.801    21654.801    1983.9754    1983.9754 
Loop time of 33.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.601 ns/day, 9.229 hours/ns, 30.099 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    | 32.642     | 32.642     | 32.642     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.128      | 0.128      | 0.128      |   0.0 |  0.39
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.38838    | 0.38838    | 0.38838    |   0.0 |  1.17
Other   |            | 0.06595    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330578.0 ave      330578 max      330578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330578
Ave neighs/atom = 165.28900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.346117613949, Press = -1.57544978042825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8007.0167   -8007.0167   -8092.4835   -8092.4835    330.76569    330.76569    21654.801    21654.801    1983.9754    1983.9754 
   32000   -8004.6033   -8004.6033   -8090.8035   -8090.8035    333.60355    333.60355    21660.929    21660.929    3144.2622    3144.2622 
Loop time of 31.7965 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.832 hours/ns, 31.450 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.237     | 31.237     | 31.237     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12459    | 0.12459    | 0.12459    |   0.0 |  0.39
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.36934    | 0.36934    | 0.36934    |   0.0 |  1.16
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331562.0 ave      331562 max      331562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331562
Ave neighs/atom = 165.78100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.191229688334, Press = -3.88328325504102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8004.6033   -8004.6033   -8090.8035   -8090.8035    333.60355    333.60355    21660.929    21660.929    3144.2622    3144.2622 
   33000    -8004.326    -8004.326   -8088.2037   -8088.2037    324.61508    324.61508    21724.004    21724.004    -619.3393    -619.3393 
Loop time of 33.4963 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.579 ns/day, 9.305 hours/ns, 29.854 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    | 32.917     | 32.917     | 32.917     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12689    | 0.12689    | 0.12689    |   0.0 |  0.38
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.38706    | 0.38706    | 0.38706    |   0.0 |  1.16
Other   |            | 0.06539    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331424.0 ave      331424 max      331424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331424
Ave neighs/atom = 165.71200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.213987657513, Press = -1.41186173775459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -8004.326    -8004.326   -8088.2037   -8088.2037    324.61508    324.61508    21724.004    21724.004    -619.3393    -619.3393 
   34000   -8001.7073   -8001.7073   -8090.5017   -8090.5017    343.64351    343.64351    21666.917    21666.917    1739.9145    1739.9145 
Loop time of 33.3927 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.587 ns/day, 9.276 hours/ns, 29.947 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    | 32.806     | 32.806     | 32.806     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12784    | 0.12784    | 0.12784    |   0.0 |  0.38
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.39183    | 0.39183    | 0.39183    |   0.0 |  1.17
Other   |            | 0.06657    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330566.0 ave      330566 max      330566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330566
Ave neighs/atom = 165.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.17904085253, Press = -1.32146085675985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8001.7073   -8001.7073   -8090.5017   -8090.5017    343.64351    343.64351    21666.917    21666.917    1739.9145    1739.9145 
   35000    -8002.184    -8002.184   -8088.1216   -8088.1216    332.58742    332.58742    21717.816    21717.816   -398.71129   -398.71129 
Loop time of 32.6297 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.648 ns/day, 9.064 hours/ns, 30.647 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    | 32.061     | 32.061     | 32.061     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1253     | 0.1253     | 0.1253     |   0.0 |  0.38
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.37755    | 0.37755    | 0.37755    |   0.0 |  1.16
Other   |            | 0.06578    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5379.00 ave        5379 max        5379 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331578.0 ave      331578 max      331578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331578
Ave neighs/atom = 165.78900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.204841711523, Press = -0.525755124968324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -8002.184    -8002.184   -8088.1216   -8088.1216    332.58742    332.58742    21717.816    21717.816   -398.71129   -398.71129 
   36000    -8004.386    -8004.386   -8092.5405   -8092.5405    341.16729    341.16729    21722.503    21722.503   -2169.9838   -2169.9838 
Loop time of 32.3705 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.669 ns/day, 8.992 hours/ns, 30.892 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    | 31.803     | 31.803     | 31.803     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12469    | 0.12469    | 0.12469    |   0.0 |  0.39
Output  | 0.00015352 | 0.00015352 | 0.00015352 |   0.0 |  0.00
Modify  | 0.37708    | 0.37708    | 0.37708    |   0.0 |  1.16
Other   |            | 0.06569    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330880.0 ave      330880 max      330880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330880
Ave neighs/atom = 165.44000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.21268607373, Press = 1.01219678952583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000    -8004.386    -8004.386   -8092.5405   -8092.5405    341.16729    341.16729    21722.503    21722.503   -2169.9838   -2169.9838 
   37000   -8008.5715   -8008.5715   -8091.3266   -8091.3266    320.27084    320.27084    21697.906    21697.906   -473.28844   -473.28844 
Loop time of 32.7817 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.106 hours/ns, 30.505 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    | 32.206     | 32.206     | 32.206     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1267     | 0.1267     | 0.1267     |   0.0 |  0.39
Output  | 0.0001565  | 0.0001565  | 0.0001565  |   0.0 |  0.00
Modify  | 0.38311    | 0.38311    | 0.38311    |   0.0 |  1.17
Other   |            | 0.06613    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5395.00 ave        5395 max        5395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330532.0 ave      330532 max      330532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330532
Ave neighs/atom = 165.26600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.191151681909, Press = -0.923343377682746
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8008.5715   -8008.5715   -8091.3266   -8091.3266    320.27084    320.27084    21697.906    21697.906   -473.28844   -473.28844 
   38000   -8003.5901   -8003.5901    -8090.814    -8090.814    337.56543    337.56543    21678.875    21678.875    1789.7209    1789.7209 
Loop time of 32.8803 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.133 hours/ns, 30.413 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    | 32.304     | 32.304     | 32.304     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12757    | 0.12757    | 0.12757    |   0.0 |  0.39
Output  | 0.00015618 | 0.00015618 | 0.00015618 |   0.0 |  0.00
Modify  | 0.38232    | 0.38232    | 0.38232    |   0.0 |  1.16
Other   |            | 0.06603    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330946.0 ave      330946 max      330946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330946
Ave neighs/atom = 165.47300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.101388565178, Press = -1.28714132523347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8003.5901   -8003.5901    -8090.814    -8090.814    337.56543    337.56543    21678.875    21678.875    1789.7209    1789.7209 
   39000   -8005.9413   -8005.9413   -8090.6482   -8090.6482    327.82446    327.82446    21621.381    21621.381    4171.7198    4171.7198 
Loop time of 32.7776 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.509 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    | 32.204     | 32.204     | 32.204     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12705    | 0.12705    | 0.12705    |   0.0 |  0.39
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.38043    | 0.38043    | 0.38043    |   0.0 |  1.16
Other   |            | 0.06572    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331226.0 ave      331226 max      331226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331226
Ave neighs/atom = 165.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035088198052, Press = 1.56674756155135
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8005.9413   -8005.9413   -8090.6482   -8090.6482    327.82446    327.82446    21621.381    21621.381    4171.7198    4171.7198 
   40000   -8005.9157   -8005.9157     -8091.98     -8091.98    333.07781    333.07781    21676.097    21676.097    438.25101    438.25101 
Loop time of 31.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.887 hours/ns, 31.256 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.43      | 31.43      | 31.43      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12502    | 0.12502    | 0.12502    |   0.0 |  0.39
Output  | 0.00015282 | 0.00015282 | 0.00015282 |   0.0 |  0.00
Modify  | 0.37282    | 0.37282    | 0.37282    |   0.0 |  1.17
Other   |            | 0.06574    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331844.0 ave      331844 max      331844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331844
Ave neighs/atom = 165.92200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.05406151012, Press = -1.79705992713326
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8005.9157   -8005.9157     -8091.98     -8091.98    333.07781    333.07781    21676.097    21676.097    438.25101    438.25101 
   41000   -8003.1099   -8003.1099      -8088.6      -8088.6    330.85544    330.85544    21715.699    21715.699      -1113.4      -1113.4 
Loop time of 32.3341 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.982 hours/ns, 30.927 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    | 31.764     | 31.764     | 31.764     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12629    | 0.12629    | 0.12629    |   0.0 |  0.39
Output  | 0.0001524  | 0.0001524  | 0.0001524  |   0.0 |  0.00
Modify  | 0.37745    | 0.37745    | 0.37745    |   0.0 |  1.17
Other   |            | 0.06574    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331242.0 ave      331242 max      331242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331242
Ave neighs/atom = 165.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.062167853855, Press = -1.73289083902183
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8003.1099   -8003.1099      -8088.6      -8088.6    330.85544    330.85544    21715.699    21715.699      -1113.4      -1113.4 
   42000   -8002.2519   -8002.2519   -8091.1326   -8091.1326    343.97762    343.97762    21679.714    21679.714    335.66643    335.66643 
Loop time of 33.2319 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.600 ns/day, 9.231 hours/ns, 30.092 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    | 32.652     | 32.652     | 32.652     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12801    | 0.12801    | 0.12801    |   0.0 |  0.39
Output  | 0.00015147 | 0.00015147 | 0.00015147 |   0.0 |  0.00
Modify  | 0.38551    | 0.38551    | 0.38551    |   0.0 |  1.16
Other   |            | 0.06594    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330668.0 ave      330668 max      330668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330668
Ave neighs/atom = 165.33400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.059357125608, Press = -1.80070519864737
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8002.2519   -8002.2519   -8091.1326   -8091.1326    343.97762    343.97762    21679.714    21679.714    335.66643    335.66643 
   43000   -8005.3131   -8005.3131   -8089.1799   -8089.1799    324.57335    324.57335    21723.268    21723.268   -1523.1339   -1523.1339 
Loop time of 32.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.133 hours/ns, 30.415 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    | 32.305     | 32.305     | 32.305     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12635    | 0.12635    | 0.12635    |   0.0 |  0.38
Output  | 0.00015312 | 0.00015312 | 0.00015312 |   0.0 |  0.00
Modify  | 0.38177    | 0.38177    | 0.38177    |   0.0 |  1.16
Other   |            | 0.06601    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331222.0 ave      331222 max      331222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331222
Ave neighs/atom = 165.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.134935180204, Press = -3.22473069788419
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8005.3131   -8005.3131   -8089.1799   -8089.1799    324.57335    324.57335    21723.268    21723.268   -1523.1339   -1523.1339 
   44000   -8001.3155   -8001.3155   -8090.8526   -8090.8526    346.51798    346.51798    21680.561    21680.561    1810.6766    1810.6766 
Loop time of 32.3145 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.976 hours/ns, 30.946 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    | 31.749     | 31.749     | 31.749     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12597    | 0.12597    | 0.12597    |   0.0 |  0.39
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.3745     | 0.3745     | 0.3745     |   0.0 |  1.16
Other   |            | 0.06526    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330604.0 ave      330604 max      330604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330604
Ave neighs/atom = 165.30200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.201802127723, Press = -4.41231512028198
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8001.3155   -8001.3155   -8090.8526   -8090.8526    346.51798    346.51798    21680.561    21680.561    1810.6766    1810.6766 
   45000    -8006.436    -8006.436   -8090.5729   -8090.5729    325.61859    325.61859    21682.128    21682.128    600.50691    600.50691 
Loop time of 32.1646 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.935 hours/ns, 31.090 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    | 31.605     | 31.605     | 31.605     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.38
Output  | 0.00015349 | 0.00015349 | 0.00015349 |   0.0 |  0.00
Modify  | 0.37116    | 0.37116    | 0.37116    |   0.0 |  1.15
Other   |            | 0.06518    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331174.0 ave      331174 max      331174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331174
Ave neighs/atom = 165.58700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.198103397115, Press = -2.28511102001059
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -8006.436    -8006.436   -8090.5729   -8090.5729    325.61859    325.61859    21682.128    21682.128    600.50691    600.50691 
   46000   -8004.5675   -8004.5675   -8091.0318   -8091.0318    334.62601    334.62601    21723.034    21723.034   -1845.2803   -1845.2803 
Loop time of 32.7013 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.084 hours/ns, 30.580 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    | 32.126     | 32.126     | 32.126     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1264     | 0.1264     | 0.1264     |   0.0 |  0.39
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.38221    | 0.38221    | 0.38221    |   0.0 |  1.17
Other   |            | 0.06674    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331204.0 ave      331204 max      331204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331204
Ave neighs/atom = 165.60200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.164924297594, Press = -0.828010718938808
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8004.5675   -8004.5675   -8091.0318   -8091.0318    334.62601    334.62601    21723.034    21723.034   -1845.2803   -1845.2803 
   47000   -8002.6317   -8002.6317   -8089.4365   -8089.4365    335.94371    335.94371    21702.051    21702.051   -747.69427   -747.69427 
Loop time of 32.5472 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.655 ns/day, 9.041 hours/ns, 30.725 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.973     | 31.973     | 31.973     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12766    | 0.12766    | 0.12766    |   0.0 |  0.39
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.3804     | 0.3804     | 0.3804     |   0.0 |  1.17
Other   |            | 0.06582    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330812.0 ave      330812 max      330812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330812
Ave neighs/atom = 165.40600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.117887120647, Press = -3.07345051638505
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8002.6317   -8002.6317   -8089.4365   -8089.4365    335.94371    335.94371    21702.051    21702.051   -747.69427   -747.69427 
   48000   -8007.0838   -8007.0838   -8092.8029   -8092.8029    331.74161    331.74161    21708.465    21708.465   -2939.9166   -2939.9166 
Loop time of 32.3025 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.973 hours/ns, 30.957 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.733     | 31.733     | 31.733     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12586    | 0.12586    | 0.12586    |   0.0 |  0.39
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.37755    | 0.37755    | 0.37755    |   0.0 |  1.17
Other   |            | 0.06556    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330762.0 ave      330762 max      330762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330762
Ave neighs/atom = 165.38100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.082465263468, Press = -4.46979740665018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8007.0838   -8007.0838   -8092.8029   -8092.8029    331.74161    331.74161    21708.465    21708.465   -2939.9166   -2939.9166 
   49000   -8002.3595   -8002.3595   -8090.0928   -8090.0928    339.53703    339.53703    21703.486    21703.486    36.220152    36.220152 
Loop time of 32.3198 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.978 hours/ns, 30.941 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    | 31.752     | 31.752     | 31.752     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12575    | 0.12575    | 0.12575    |   0.0 |  0.39
Output  | 0.00015457 | 0.00015457 | 0.00015457 |   0.0 |  0.00
Modify  | 0.3761     | 0.3761     | 0.3761     |   0.0 |  1.16
Other   |            | 0.06536    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330938.0 ave      330938 max      330938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330938
Ave neighs/atom = 165.46900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.078076741859, Press = -1.47136480529189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8002.3595   -8002.3595   -8090.0928   -8090.0928    339.53703    339.53703    21703.486    21703.486    36.220152    36.220152 
   50000   -8002.9931   -8002.9931   -8090.2568   -8090.2568    337.71955    337.71955    21703.486    21703.486   -450.46346   -450.46346 
Loop time of 32.9998 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.167 hours/ns, 30.303 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.423     | 32.423     | 32.423     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12677    | 0.12677    | 0.12677    |   0.0 |  0.38
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.38408    | 0.38408    | 0.38408    |   0.0 |  1.16
Other   |            | 0.06589    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330838.0 ave      330838 max      330838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330838
Ave neighs/atom = 165.41900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.041583518102, Press = -1.22429971783088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8002.9931   -8002.9931   -8090.2568   -8090.2568    337.71955    337.71955    21703.486    21703.486   -450.46346   -450.46346 
   51000    -8010.158    -8010.158    -8093.598    -8093.598    322.92166    322.92166    21729.567    21729.567   -3121.0406   -3121.0406 
Loop time of 32.1141 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.921 hours/ns, 31.139 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    | 31.55      | 31.55      | 31.55      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12534    | 0.12534    | 0.12534    |   0.0 |  0.39
Output  | 0.00014675 | 0.00014675 | 0.00014675 |   0.0 |  0.00
Modify  | 0.37296    | 0.37296    | 0.37296    |   0.0 |  1.16
Other   |            | 0.06546    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330962.0 ave      330962 max      330962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330962
Ave neighs/atom = 165.48100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.989512727779, Press = -1.80242728429985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -8010.158    -8010.158    -8093.598    -8093.598    322.92166    322.92166    21729.567    21729.567   -3121.0406   -3121.0406 
   52000   -8001.6876   -8001.6876   -8089.6719   -8089.6719    340.50816    340.50816    21698.687    21698.687    -792.1417    -792.1417 
Loop time of 31.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.748 ns/day, 8.734 hours/ns, 31.806 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    | 30.885     | 30.885     | 30.885     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.39
Output  | 0.00015569 | 0.00015569 | 0.00015569 |   0.0 |  0.00
Modify  | 0.36727    | 0.36727    | 0.36727    |   0.0 |  1.17
Other   |            | 0.06532    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330424.0 ave      330424 max      330424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330424
Ave neighs/atom = 165.21200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.989904499113, Press = -0.426268053914698
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8001.6876   -8001.6876   -8089.6719   -8089.6719    340.50816    340.50816    21698.687    21698.687    -792.1417    -792.1417 
   53000   -8004.1031   -8004.1031   -8089.6084   -8089.6084     330.9144     330.9144    21707.373    21707.373   -269.61451   -269.61451 
Loop time of 33.4957 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.579 ns/day, 9.304 hours/ns, 29.855 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    | 32.912     | 32.912     | 32.912     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1293     | 0.1293     | 0.1293     |   0.0 |  0.39
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.3878     | 0.3878     | 0.3878     |   0.0 |  1.16
Other   |            | 0.06614    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331078.0 ave      331078 max      331078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331078
Ave neighs/atom = 165.53900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.958665955561, Press = -0.419396635547761
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8004.1031   -8004.1031   -8089.6084   -8089.6084     330.9144     330.9144    21707.373    21707.373   -269.61451   -269.61451 
   54000     -8007.18     -8007.18    -8090.763    -8090.763    323.47481    323.47481    21671.064    21671.064    63.363133    63.363133 
Loop time of 33.0194 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.617 ns/day, 9.172 hours/ns, 30.285 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    | 32.44      | 32.44      | 32.44      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12828    | 0.12828    | 0.12828    |   0.0 |  0.39
Output  | 0.00015202 | 0.00015202 | 0.00015202 |   0.0 |  0.00
Modify  | 0.38486    | 0.38486    | 0.38486    |   0.0 |  1.17
Other   |            | 0.06564    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330896.0 ave      330896 max      330896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330896
Ave neighs/atom = 165.44800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.918659883406, Press = -3.35593982868667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000     -8007.18     -8007.18    -8090.763    -8090.763    323.47481    323.47481    21671.064    21671.064    63.363133    63.363133 
   55000   -8002.8921   -8002.8921   -8092.2201   -8092.2201    345.70869    345.70869    21670.834    21670.834    1007.4185    1007.4185 
Loop time of 32.4577 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.016 hours/ns, 30.809 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.887     | 31.887     | 31.887     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12612    | 0.12612    | 0.12612    |   0.0 |  0.39
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.37906    | 0.37906    | 0.37906    |   0.0 |  1.17
Other   |            | 0.06573    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331256.0 ave      331256 max      331256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331256
Ave neighs/atom = 165.62800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.939920791896, Press = -1.1473862443229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8002.8921   -8002.8921   -8092.2201   -8092.2201    345.70869    345.70869    21670.834    21670.834    1007.4185    1007.4185 
   56000   -8001.9718   -8001.9718   -8089.8994   -8089.8994    340.28902    340.28902    21709.218    21709.218   -526.16689   -526.16689 
Loop time of 31.4908 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.744 ns/day, 8.747 hours/ns, 31.755 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.935     | 30.935     | 30.935     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.39
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.36847    | 0.36847    | 0.36847    |   0.0 |  1.17
Other   |            | 0.06486    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331214.0 ave      331214 max      331214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331214
Ave neighs/atom = 165.60700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.966756191594, Press = 1.89502014807866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8001.9718   -8001.9718   -8089.8994   -8089.8994    340.28902    340.28902    21709.218    21709.218   -526.16689   -526.16689 
   57000   -8006.0206   -8006.0206   -8092.7875   -8092.7875     335.7971     335.7971    21683.434    21683.434   -449.05912   -449.05912 
Loop time of 32.339 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.983 hours/ns, 30.922 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    | 31.775     | 31.775     | 31.775     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12524    | 0.12524    | 0.12524    |   0.0 |  0.39
Output  | 0.00015972 | 0.00015972 | 0.00015972 |   0.0 |  0.00
Modify  | 0.3732     | 0.3732     | 0.3732     |   0.0 |  1.15
Other   |            | 0.06569    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331014.0 ave      331014 max      331014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331014
Ave neighs/atom = 165.50700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.015987949138, Press = -1.01581742498818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8006.0206   -8006.0206   -8092.7875   -8092.7875     335.7971     335.7971    21683.434    21683.434   -449.05912   -449.05912 
   58000   -8007.2254   -8007.2254   -8091.2617   -8091.2617    325.22942    325.22942    21714.483    21714.483   -2245.6361   -2245.6361 
Loop time of 32.1168 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.921 hours/ns, 31.136 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    | 31.554     | 31.554     | 31.554     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1239     | 0.1239     | 0.1239     |   0.0 |  0.39
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.37344    | 0.37344    | 0.37344    |   0.0 |  1.16
Other   |            | 0.06527    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331008.0 ave      331008 max      331008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331008
Ave neighs/atom = 165.50400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.049709640553, Press = -0.57894754390692
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8007.2254   -8007.2254   -8091.2617   -8091.2617    325.22942    325.22942    21714.483    21714.483   -2245.6361   -2245.6361 
   59000    -8003.993    -8003.993   -8088.9531   -8088.9531    328.80439    328.80439    21726.472    21726.472   -2182.8166   -2182.8166 
Loop time of 33.2338 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.600 ns/day, 9.232 hours/ns, 30.090 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    | 32.656     | 32.656     | 32.656     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.127      | 0.127      | 0.127      |   0.0 |  0.38
Output  | 0.0001613  | 0.0001613  | 0.0001613  |   0.0 |  0.00
Modify  | 0.38485    | 0.38485    | 0.38485    |   0.0 |  1.16
Other   |            | 0.06562    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330660.0 ave      330660 max      330660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330660
Ave neighs/atom = 165.33000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.05802476753, Press = -1.68014522523607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000    -8003.993    -8003.993   -8088.9531   -8088.9531    328.80439    328.80439    21726.472    21726.472   -2182.8166   -2182.8166 
   60000   -8004.4847   -8004.4847   -8090.2864   -8090.2864    332.06146    332.06146    21710.959    21710.959   -306.81453   -306.81453 
Loop time of 32.8097 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.114 hours/ns, 30.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.233     | 32.233     | 32.233     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12689    | 0.12689    | 0.12689    |   0.0 |  0.39
Output  | 0.00015139 | 0.00015139 | 0.00015139 |   0.0 |  0.00
Modify  | 0.3846     | 0.3846     | 0.3846     |   0.0 |  1.17
Other   |            | 0.06528    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5395.00 ave        5395 max        5395 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330296.0 ave      330296 max      330296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330296
Ave neighs/atom = 165.14800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.020364340534, Press = -0.599369700571627
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8004.4847   -8004.4847   -8090.2864   -8090.2864    332.06146    332.06146    21710.959    21710.959   -306.81453   -306.81453 
   61000   -8005.1381   -8005.1381   -8089.9559   -8089.9559    328.25365    328.25365    21698.683    21698.683   -225.23495   -225.23495 
Loop time of 32.3852 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.878 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    | 31.816     | 31.816     | 31.816     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12563    | 0.12563    | 0.12563    |   0.0 |  0.39
Output  | 0.00015813 | 0.00015813 | 0.00015813 |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  1.17
Other   |            | 0.06567    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330716.0 ave      330716 max      330716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330716
Ave neighs/atom = 165.35800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.038458433684, Press = -0.836271054103741
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8005.1381   -8005.1381   -8089.9559   -8089.9559    328.25365    328.25365    21698.683    21698.683   -225.23495   -225.23495 
   62000   -8003.0117   -8003.0117   -8089.6582   -8089.6582    335.33074    335.33074    21708.953    21708.953   -169.72363   -169.72363 
Loop time of 31.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.668 hours/ns, 32.046 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    | 30.65      | 30.65      | 30.65      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.39
Output  | 0.00015863 | 0.00015863 | 0.00015863 |   0.0 |  0.00
Modify  | 0.36566    | 0.36566    | 0.36566    |   0.0 |  1.17
Other   |            | 0.0659     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331082.0 ave      331082 max      331082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331082
Ave neighs/atom = 165.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.051984118825, Press = -1.36518228790465
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8003.0117   -8003.0117   -8089.6582   -8089.6582    335.33074    335.33074    21708.953    21708.953   -169.72363   -169.72363 
   63000    -8004.817    -8004.817   -8090.2457   -8090.2457    330.61797    330.61797     21665.05     21665.05    2473.1002    2473.1002 
Loop time of 31.5492 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.739 ns/day, 8.764 hours/ns, 31.697 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    | 30.989     | 30.989     | 30.989     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.124      | 0.124      | 0.124      |   0.0 |  0.39
Output  | 0.00015243 | 0.00015243 | 0.00015243 |   0.0 |  0.00
Modify  | 0.37062    | 0.37062    | 0.37062    |   0.0 |  1.17
Other   |            | 0.06548    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330772.0 ave      330772 max      330772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330772
Ave neighs/atom = 165.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.99405685842, Press = -1.81790764612485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -8004.817    -8004.817   -8090.2457   -8090.2457    330.61797    330.61797     21665.05     21665.05    2473.1002    2473.1002 
   64000   -8005.6646   -8005.6646   -8092.7208   -8092.7208    336.91659    336.91659    21720.135    21720.135   -1860.7899   -1860.7899 
Loop time of 32.196 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.684 ns/day, 8.943 hours/ns, 31.060 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    | 31.629     | 31.629     | 31.629     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12582    | 0.12582    | 0.12582    |   0.0 |  0.39
Output  | 0.00019546 | 0.00019546 | 0.00019546 |   0.0 |  0.00
Modify  | 0.37542    | 0.37542    | 0.37542    |   0.0 |  1.17
Other   |            | 0.06587    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331394.0 ave      331394 max      331394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331394
Ave neighs/atom = 165.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.008327672809, Press = -2.42823030288755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8005.6646   -8005.6646   -8092.7208   -8092.7208    336.91659    336.91659    21720.135    21720.135   -1860.7899   -1860.7899 
   65000   -8002.5714   -8002.5714   -8088.7513   -8088.7513    333.52514    333.52514     21731.09     21731.09   -1016.0942   -1016.0942 
Loop time of 31.7364 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.816 hours/ns, 31.510 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.175     | 31.175     | 31.175     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.39
Output  | 0.00015451 | 0.00015451 | 0.00015451 |   0.0 |  0.00
Modify  | 0.371      | 0.371      | 0.371      |   0.0 |  1.17
Other   |            | 0.06549    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330464.0 ave      330464 max      330464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330464
Ave neighs/atom = 165.23200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.019232727056, Press = -1.07120965198845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8002.5714   -8002.5714   -8088.7513   -8088.7513    333.52514    333.52514     21731.09     21731.09   -1016.0942   -1016.0942 
   66000   -8004.7875   -8004.7875   -8090.5482   -8090.5482    331.90293    331.90293    21757.885    21757.885   -4206.2239   -4206.2239 
Loop time of 31.5016 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.743 ns/day, 8.750 hours/ns, 31.744 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    | 30.943     | 30.943     | 30.943     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12389    | 0.12389    | 0.12389    |   0.0 |  0.39
Output  | 0.00020323 | 0.00020323 | 0.00020323 |   0.0 |  0.00
Modify  | 0.36913    | 0.36913    | 0.36913    |   0.0 |  1.17
Other   |            | 0.06545    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330606.0 ave      330606 max      330606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330606
Ave neighs/atom = 165.30300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.043014852097, Press = -1.07112623902995
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8004.7875   -8004.7875   -8090.5482   -8090.5482    331.90293    331.90293    21757.885    21757.885   -4206.2239   -4206.2239 
   67000     -8003.86     -8003.86   -8088.6952   -8088.6952    328.32113    328.32113    21694.964    21694.964    333.82877    333.82877 
Loop time of 32.3866 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.877 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.815     | 31.815     | 31.815     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12579    | 0.12579    | 0.12579    |   0.0 |  0.39
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.37945    | 0.37945    | 0.37945    |   0.0 |  1.17
Other   |            | 0.06662    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5400.00 ave        5400 max        5400 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330134.0 ave      330134 max      330134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330134
Ave neighs/atom = 165.06700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.068210818164, Press = -0.963141902926807
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000     -8003.86     -8003.86   -8088.6952   -8088.6952    328.32113    328.32113    21694.964    21694.964    333.82877    333.82877 
   68000     -8006.23     -8006.23   -8089.5077   -8089.5077    322.29331    322.29331    21672.532    21672.532    1091.3896    1091.3896 
Loop time of 32.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.669 ns/day, 8.991 hours/ns, 30.897 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    | 31.798     | 31.798     | 31.798     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1254     | 0.1254     | 0.1254     |   0.0 |  0.39
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.37625    | 0.37625    | 0.37625    |   0.0 |  1.16
Other   |            | 0.06608    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331248.0 ave      331248 max      331248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331248
Ave neighs/atom = 165.62400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.043549741676, Press = -1.5655333284865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000     -8006.23     -8006.23   -8089.5077   -8089.5077    322.29331    322.29331    21672.532    21672.532    1091.3896    1091.3896 
   69000   -8002.8203   -8002.8203   -8089.7747   -8089.7747    336.52265    336.52265    21676.389    21676.389    1505.2037    1505.2037 
Loop time of 31.3006 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.695 hours/ns, 31.948 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    | 30.744     | 30.744     | 30.744     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.39
Output  | 0.00015077 | 0.00015077 | 0.00015077 |   0.0 |  0.00
Modify  | 0.36703    | 0.36703    | 0.36703    |   0.0 |  1.17
Other   |            | 0.06553    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331264.0 ave      331264 max      331264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331264
Ave neighs/atom = 165.63200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.061389031505, Press = -1.19841389926208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8002.8203   -8002.8203   -8089.7747   -8089.7747    336.52265    336.52265    21676.389    21676.389    1505.2037    1505.2037 
   70000   -8006.7903   -8006.7903   -8090.4925   -8090.4925    323.93623    323.93623    21688.993    21688.993    554.79912    554.79912 
Loop time of 31.7958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.832 hours/ns, 31.451 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    | 31.235     | 31.235     | 31.235     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12351    | 0.12351    | 0.12351    |   0.0 |  0.39
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.37117    | 0.37117    | 0.37117    |   0.0 |  1.17
Other   |            | 0.06547    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      331048.0 ave      331048 max      331048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 331048
Ave neighs/atom = 165.52400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.08684653641, Press = -1.79629865188875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8006.7903   -8006.7903   -8090.4925   -8090.4925    323.93623    323.93623    21688.993    21688.993    554.79912    554.79912 
   71000   -8003.5665   -8003.5665   -8090.7136   -8090.7136     337.2686     337.2686    21734.668    21734.668   -2199.4493   -2199.4493 
Loop time of 31.0248 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.785 ns/day, 8.618 hours/ns, 32.232 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.474     | 30.474     | 30.474     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12226    | 0.12226    | 0.12226    |   0.0 |  0.39
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.36273    | 0.36273    | 0.36273    |   0.0 |  1.17
Other   |            | 0.0654     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330982.0 ave      330982 max      330982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330982
Ave neighs/atom = 165.49100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.09560431718, Press = -0.424376885126215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8003.5665   -8003.5665   -8090.7136   -8090.7136     337.2686     337.2686    21734.668    21734.668   -2199.4493   -2199.4493 
   72000   -8007.6674   -8007.6674   -8092.1201   -8092.1201    326.84078    326.84078    21678.915    21678.915    204.51235    204.51235 
Loop time of 31.7101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.808 hours/ns, 31.536 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    | 31.151     | 31.151     | 31.151     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12412    | 0.12412    | 0.12412    |   0.0 |  0.39
Output  | 0.0001521  | 0.0001521  | 0.0001521  |   0.0 |  0.00
Modify  | 0.36952    | 0.36952    | 0.36952    |   0.0 |  1.17
Other   |            | 0.06509    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      330580.0 ave      330580 max      330580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 330580
Ave neighs/atom = 165.29000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
21691.8331594651

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0