# 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.938573218882084*${_u_distance}
variable latticeconst_converted equal 2.938573218882084*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.93857321888208
Lattice spacing in x,y,z = 2.9385732 2.9385732 2.9385732
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 (29.385732 29.385732 29.385732)
  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 (29.385732 29.385732 29.385732)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BelandTammMu_2017_FeNiCr__MO_715003088863_000
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 25375.2043761954 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_715003088863_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.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -6974.841    -6974.841   -7045.4205   -7045.4205       273.15       273.15    25375.204    25375.204    2970.9357    2970.9357 
    1000    -7078.333    -7078.333   -7147.6072   -7147.6072    268.09834    268.09834    24101.175    24101.175   -528.63831   -528.63831 
Loop time of 30.7273 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.812 ns/day, 8.535 hours/ns, 32.544 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    | 29.971     | 29.971     | 29.971     |   0.0 | 97.54
Neigh   | 0.1917     | 0.1917     | 0.1917     |   0.0 |  0.62
Comm    | 0.13439    | 0.13439    | 0.13439    |   0.0 |  0.44
Output  | 0.00019811 | 0.00019811 | 0.00019811 |   0.0 |  0.00
Modify  | 0.36494    | 0.36494    | 0.36494    |   0.0 |  1.19
Other   |            | 0.0651     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5235.00 ave        5235 max        5235 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      306482.0 ave      306482 max      306482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 306482
Ave neighs/atom = 153.24100
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -7078.333    -7078.333   -7147.6072   -7147.6072    268.09834    268.09834    24101.175    24101.175   -528.63831   -528.63831 
    2000   -7121.3477   -7121.3477   -7191.9151   -7191.9151    273.10345    273.10345    23534.182    23534.182     1116.342     1116.342 
Loop time of 31.3559 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.710 hours/ns, 31.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    | 30.629     | 30.629     | 30.629     |   0.0 | 97.68
Neigh   | 0.18753    | 0.18753    | 0.18753    |   0.0 |  0.60
Comm    | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.39
Output  | 0.00019071 | 0.00019071 | 0.00019071 |   0.0 |  0.00
Modify  | 0.35183    | 0.35183    | 0.35183    |   0.0 |  1.12
Other   |            | 0.06417    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312216.0 ave      312216 max      312216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312216
Ave neighs/atom = 156.10800
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7121.3477   -7121.3477   -7191.9151   -7191.9151    273.10345    273.10345    23534.182    23534.182     1116.342     1116.342 
    3000   -7128.6007   -7128.6007   -7197.5891   -7197.5891    266.99197    266.99197    23572.102    23572.102   -4525.6698   -4525.6698 
Loop time of 30.7478 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.810 ns/day, 8.541 hours/ns, 32.523 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.119     | 30.119     | 30.119     |   0.0 | 97.95
Neigh   | 0.098311   | 0.098311   | 0.098311   |   0.0 |  0.32
Comm    | 0.12057    | 0.12057    | 0.12057    |   0.0 |  0.39
Output  | 0.00019359 | 0.00019359 | 0.00019359 |   0.0 |  0.00
Modify  | 0.34603    | 0.34603    | 0.34603    |   0.0 |  1.13
Other   |            | 0.06397    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311706.0 ave      311706 max      311706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311706
Ave neighs/atom = 155.85300
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7128.6007   -7128.6007   -7197.5891   -7197.5891    266.99197    266.99197    23572.102    23572.102   -4525.6698   -4525.6698 
    4000   -7139.2425   -7139.2425   -7210.5622   -7210.5622    276.01445    276.01445    23449.538    23449.538     1071.602     1071.602 
Loop time of 31.4782 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.744 hours/ns, 31.768 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.844     | 30.844     | 30.844     |   0.0 | 97.99
Neigh   | 0.093079   | 0.093079   | 0.093079   |   0.0 |  0.30
Comm    | 0.1221     | 0.1221     | 0.1221     |   0.0 |  0.39
Output  | 0.0001903  | 0.0001903  | 0.0001903  |   0.0 |  0.00
Modify  | 0.35403    | 0.35403    | 0.35403    |   0.0 |  1.12
Other   |            | 0.06443    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312220.0 ave      312220 max      312220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312220
Ave neighs/atom = 156.11000
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7139.2425   -7139.2425   -7210.5622   -7210.5622    276.01445    276.01445    23449.538    23449.538     1071.602     1071.602 
    5000   -7142.4147   -7142.4147   -7209.7221   -7209.7221     260.4865     260.4865    23490.539    23490.539      -1222.5      -1222.5 
Loop time of 31.1447 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.774 ns/day, 8.651 hours/ns, 32.108 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.559     | 30.559     | 30.559     |   0.0 | 98.12
Neigh   | 0.046463   | 0.046463   | 0.046463   |   0.0 |  0.15
Comm    | 0.1218     | 0.1218     | 0.1218     |   0.0 |  0.39
Output  | 0.00015684 | 0.00015684 | 0.00015684 |   0.0 |  0.00
Modify  | 0.35291    | 0.35291    | 0.35291    |   0.0 |  1.13
Other   |            | 0.06441    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5149.00 ave        5149 max        5149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311136.0 ave      311136 max      311136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311136
Ave neighs/atom = 155.56800
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 267.107375010419, Press = 1468.74532365632
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -7142.4147   -7142.4147   -7209.7221   -7209.7221     260.4865     260.4865    23490.539    23490.539      -1222.5      -1222.5 
    6000   -7140.7593   -7140.7593   -7209.1318   -7209.1318    264.60861    264.60861     23475.17     23475.17     440.6168     440.6168 
Loop time of 30.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.816 ns/day, 8.524 hours/ns, 32.589 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.135     | 30.135     | 30.135     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11908    | 0.11908    | 0.11908    |   0.0 |  0.39
Output  | 0.00019945 | 0.00019945 | 0.00019945 |   0.0 |  0.00
Modify  | 0.36641    | 0.36641    | 0.36641    |   0.0 |  1.19
Other   |            | 0.06432    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312268.0 ave      312268 max      312268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312268
Ave neighs/atom = 156.13400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920889559269, Press = 51.5489648008918
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7140.7593   -7140.7593   -7209.1318   -7209.1318    264.60861    264.60861     23475.17     23475.17     440.6168     440.6168 
    7000   -7139.5503   -7139.5503   -7211.1291   -7211.1291    277.01707    277.01707    23508.987    23508.987   -1236.8938   -1236.8938 
Loop time of 30.6591 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.818 ns/day, 8.516 hours/ns, 32.617 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.107     | 30.107     | 30.107     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11982    | 0.11982    | 0.11982    |   0.0 |  0.39
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.36796    | 0.36796    | 0.36796    |   0.0 |  1.20
Other   |            | 0.06402    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312078.0 ave      312078 max      312078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312078
Ave neighs/atom = 156.03900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.000381177281, Press = 19.6369092794494
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7139.5503   -7139.5503   -7211.1291   -7211.1291    277.01707    277.01707    23508.987    23508.987   -1236.8938   -1236.8938 
    8000   -7141.2602   -7141.2602     -7210.67     -7210.67    268.62314    268.62314    23487.117    23487.117    561.53291    561.53291 
Loop time of 31.3015 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.760 ns/day, 8.695 hours/ns, 31.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    | 30.732     | 30.732     | 30.732     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12336    | 0.12336    | 0.12336    |   0.0 |  0.39
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.38062    | 0.38062    | 0.38062    |   0.0 |  1.22
Other   |            | 0.06504    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311458.0 ave      311458 max      311458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311458
Ave neighs/atom = 155.72900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856494520071, Press = 51.0783919917744
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7141.2602   -7141.2602     -7210.67     -7210.67    268.62314    268.62314    23487.117    23487.117    561.53291    561.53291 
    9000   -7139.2328   -7139.2328   -7209.7222   -7209.7222    272.80113    272.80113    23503.571    23503.571    661.90949    661.90949 
Loop time of 30.9399 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.793 ns/day, 8.594 hours/ns, 32.321 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.382     | 30.382     | 30.382     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12112    | 0.12112    | 0.12112    |   0.0 |  0.39
Output  | 0.00018352 | 0.00018352 | 0.00018352 |   0.0 |  0.00
Modify  | 0.37213    | 0.37213    | 0.37213    |   0.0 |  1.20
Other   |            | 0.06475    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311704.0 ave      311704 max      311704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311704
Ave neighs/atom = 155.85200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.341813404008, Press = 19.056186589166
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7139.2328   -7139.2328   -7209.7222   -7209.7222    272.80113    272.80113    23503.571    23503.571    661.90949    661.90949 
   10000   -7140.5101   -7140.5101   -7210.5324   -7210.5324    270.99364    270.99364    23513.486    23513.486    -1377.611    -1377.611 
Loop time of 30.6131 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.822 ns/day, 8.504 hours/ns, 32.666 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.059     | 30.059     | 30.059     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11964    | 0.11964    | 0.11964    |   0.0 |  0.39
Output  | 0.00020379 | 0.00020379 | 0.00020379 |   0.0 |  0.00
Modify  | 0.37007    | 0.37007    | 0.37007    |   0.0 |  1.21
Other   |            | 0.06405    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5145.00 ave        5145 max        5145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311564.0 ave      311564 max      311564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311564
Ave neighs/atom = 155.78200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.510356242606, Press = 9.02725090378333
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7140.5101   -7140.5101   -7210.5324   -7210.5324    270.99364    270.99364    23513.486    23513.486    -1377.611    -1377.611 
   11000   -7139.0697   -7139.0697   -7210.3252   -7210.3252    275.76627    275.76627    23502.125    23502.125   -650.83958   -650.83958 
Loop time of 30.4183 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.840 ns/day, 8.450 hours/ns, 32.875 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.863     | 29.863     | 29.863     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12059    | 0.12059    | 0.12059    |   0.0 |  0.40
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.37023    | 0.37023    | 0.37023    |   0.0 |  1.22
Other   |            | 0.064      |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5169.00 ave        5169 max        5169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311576.0 ave      311576 max      311576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311576
Ave neighs/atom = 155.78800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.88093175813, Press = 12.7887618433455
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7139.0697   -7139.0697   -7210.3252   -7210.3252    275.76627    275.76627    23502.125    23502.125   -650.83958   -650.83958 
   12000   -7139.1498   -7139.1498   -7210.8973   -7210.8973    277.66989    277.66989    23471.374    23471.374    2497.1049    2497.1049 
Loop time of 31.1521 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.773 ns/day, 8.653 hours/ns, 32.101 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.597     | 30.597     | 30.597     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12099    | 0.12099    | 0.12099    |   0.0 |  0.39
Output  | 0.00020068 | 0.00020068 | 0.00020068 |   0.0 |  0.00
Modify  | 0.36994    | 0.36994    | 0.36994    |   0.0 |  1.19
Other   |            | 0.06431    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311704.0 ave      311704 max      311704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311704
Ave neighs/atom = 155.85200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.819256035534, Press = 23.7347584325583
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7139.1498   -7139.1498   -7210.8973   -7210.8973    277.66989    277.66989    23471.374    23471.374    2497.1049    2497.1049 
   13000   -7143.7408   -7143.7408   -7213.3158   -7213.3158    269.26236    269.26236    23521.586    23521.586    -2074.563    -2074.563 
Loop time of 32.3066 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.974 hours/ns, 30.953 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.731     | 31.731     | 31.731     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12444    | 0.12444    | 0.12444    |   0.0 |  0.39
Output  | 0.0001922  | 0.0001922  | 0.0001922  |   0.0 |  0.00
Modify  | 0.38632    | 0.38632    | 0.38632    |   0.0 |  1.20
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5166.00 ave        5166 max        5166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311786.0 ave      311786 max      311786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311786
Ave neighs/atom = 155.89300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.602754229416, Press = 3.08754081271517
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7143.7408   -7143.7408   -7213.3158   -7213.3158    269.26236    269.26236    23521.586    23521.586    -2074.563    -2074.563 
   14000   -7140.2644   -7140.2644   -7210.7198   -7210.7198    272.66962    272.66962    23497.935    23497.935   -219.17337   -219.17337 
Loop time of 30.7921 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.806 ns/day, 8.553 hours/ns, 32.476 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.227     | 30.227     | 30.227     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12222    | 0.12222    | 0.12222    |   0.0 |  0.40
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.37714    | 0.37714    | 0.37714    |   0.0 |  1.22
Other   |            | 0.06527    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 155.85100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.692629834419, Press = 2.58427916110621
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -7140.2644   -7140.2644   -7210.7198   -7210.7198    272.66962    272.66962    23497.935    23497.935   -219.17337   -219.17337 
   15000    -7138.711    -7138.711    -7209.281    -7209.281    273.11305    273.11305    23515.372    23515.372   -1505.6429   -1505.6429 
Loop time of 30.4329 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.839 ns/day, 8.454 hours/ns, 32.859 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    | 29.882     | 29.882     | 29.882     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1193     | 0.1193     | 0.1193     |   0.0 |  0.39
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.36819    | 0.36819    | 0.36819    |   0.0 |  1.21
Other   |            | 0.06375    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311750.0 ave      311750 max      311750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311750
Ave neighs/atom = 155.87500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.764250294132, Press = 12.9435347485119
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -7138.711    -7138.711    -7209.281    -7209.281    273.11305    273.11305    23515.372    23515.372   -1505.6429   -1505.6429 
   16000   -7140.6065   -7140.6065   -7211.3426   -7211.3426    273.75594    273.75594    23449.904    23449.904    3332.3026    3332.3026 
Loop time of 30.6869 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.816 ns/day, 8.524 hours/ns, 32.587 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.13      | 30.13      | 30.13      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.40
Output  | 0.00014856 | 0.00014856 | 0.00014856 |   0.0 |  0.00
Modify  | 0.37162    | 0.37162    | 0.37162    |   0.0 |  1.21
Other   |            | 0.06414    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311206.0 ave      311206 max      311206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311206
Ave neighs/atom = 155.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633138745133, Press = 11.9202608347407
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7140.6065   -7140.6065   -7211.3426   -7211.3426    273.75594    273.75594    23449.904    23449.904    3332.3026    3332.3026 
   17000   -7141.1028   -7141.1028   -7209.5371   -7209.5371    264.84791    264.84791    23503.866    23503.866   -1139.5442   -1139.5442 
Loop time of 30.6522 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.819 ns/day, 8.515 hours/ns, 32.624 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.099     | 30.099     | 30.099     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11951    | 0.11951    | 0.11951    |   0.0 |  0.39
Output  | 0.00015726 | 0.00015726 | 0.00015726 |   0.0 |  0.00
Modify  | 0.36925    | 0.36925    | 0.36925    |   0.0 |  1.20
Other   |            | 0.06442    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312592.0 ave      312592 max      312592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312592
Ave neighs/atom = 156.29600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.560528228864, Press = 2.11667927934182
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7141.1028   -7141.1028   -7209.5371   -7209.5371    264.84791    264.84791    23503.866    23503.866   -1139.5442   -1139.5442 
   18000   -7142.0012   -7142.0012    -7211.627    -7211.627    269.45927    269.45927    23502.414    23502.414   -54.987677   -54.987677 
Loop time of 30.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.836 ns/day, 8.464 hours/ns, 32.820 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    | 29.912     | 29.912     | 29.912     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12081    | 0.12081    | 0.12081    |   0.0 |  0.40
Output  | 0.00015641 | 0.00015641 | 0.00015641 |   0.0 |  0.00
Modify  | 0.37175    | 0.37175    | 0.37175    |   0.0 |  1.22
Other   |            | 0.06474    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311754.0 ave      311754 max      311754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311754
Ave neighs/atom = 155.87700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.489121967505, Press = 7.80636658948949
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7142.0012   -7142.0012    -7211.627    -7211.627    269.45927    269.45927    23502.414    23502.414   -54.987677   -54.987677 
   19000   -7136.5315   -7136.5315    -7209.339    -7209.339     281.7728     281.7728    23463.921    23463.921    1711.8584    1711.8584 
Loop time of 30.5595 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.489 hours/ns, 32.723 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.003     | 30.003     | 30.003     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12014    | 0.12014    | 0.12014    |   0.0 |  0.39
Output  | 0.00015419 | 0.00015419 | 0.00015419 |   0.0 |  0.00
Modify  | 0.37184    | 0.37184    | 0.37184    |   0.0 |  1.22
Other   |            | 0.0643     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311472.0 ave      311472 max      311472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311472
Ave neighs/atom = 155.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.655725104511, Press = 5.20157755154868
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7136.5315   -7136.5315    -7209.339    -7209.339     281.7728     281.7728    23463.921    23463.921    1711.8584    1711.8584 
   20000   -7138.3508   -7138.3508   -7210.0825   -7210.0825    277.60912    277.60912    23525.154    23525.154   -1637.3085   -1637.3085 
Loop time of 30.6179 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.822 ns/day, 8.505 hours/ns, 32.661 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.064     | 30.064     | 30.064     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12068    | 0.12068    | 0.12068    |   0.0 |  0.39
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.36881    | 0.36881    | 0.36881    |   0.0 |  1.20
Other   |            | 0.0641     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312284.0 ave      312284 max      312284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312284
Ave neighs/atom = 156.14200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.692826113961, Press = 5.52643172462039
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7138.3508   -7138.3508   -7210.0825   -7210.0825    277.60912    277.60912    23525.154    23525.154   -1637.3085   -1637.3085 
   21000   -7142.3734   -7142.3734   -7210.4612   -7210.4612    263.50664    263.50664    23508.582    23508.582   -372.53231   -372.53231 
Loop time of 30.7549 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.809 ns/day, 8.543 hours/ns, 32.515 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.196     | 30.196     | 30.196     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.37326    | 0.37326    | 0.37326    |   0.0 |  1.21
Other   |            | 0.06454    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311330.0 ave      311330 max      311330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311330
Ave neighs/atom = 155.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.654221542933, Press = -0.95406540105943
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7142.3734   -7142.3734   -7210.4612   -7210.4612    263.50664    263.50664    23508.582    23508.582   -372.53231   -372.53231 
   22000   -7139.7329   -7139.7329    -7210.719    -7210.719    274.72388    274.72388    23500.685    23500.685   -442.40729   -442.40729 
Loop time of 30.9116 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.795 ns/day, 8.587 hours/ns, 32.350 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.346     | 30.346     | 30.346     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.39
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.37897    | 0.37897    | 0.37897    |   0.0 |  1.23
Other   |            | 0.06528    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5133.00 ave        5133 max        5133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311460.0 ave      311460 max      311460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311460
Ave neighs/atom = 155.73000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.58947451035, Press = 6.8505861946145
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7139.7329   -7139.7329    -7210.719    -7210.719    274.72388    274.72388    23500.685    23500.685   -442.40729   -442.40729 
   23000   -7142.1117   -7142.1117   -7210.7814   -7210.7814    265.75874    265.75874    23461.759    23461.759    2093.8109    2093.8109 
Loop time of 30.8338 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.802 ns/day, 8.565 hours/ns, 32.432 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.276     | 30.276     | 30.276     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12005    | 0.12005    | 0.12005    |   0.0 |  0.39
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.37293    | 0.37293    | 0.37293    |   0.0 |  1.21
Other   |            | 0.06462    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5132.00 ave        5132 max        5132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312052.0 ave      312052 max      312052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312052
Ave neighs/atom = 156.02600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.583323055995, Press = 5.62541786265459
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7142.1117   -7142.1117   -7210.7814   -7210.7814    265.75874    265.75874    23461.759    23461.759    2093.8109    2093.8109 
   24000   -7140.7412   -7140.7412   -7210.9903   -7210.9903    271.87157    271.87157    23523.518    23523.518   -1692.2532   -1692.2532 
Loop time of 30.4035 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.842 ns/day, 8.445 hours/ns, 32.891 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    | 29.849     | 29.849     | 29.849     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12105    | 0.12105    | 0.12105    |   0.0 |  0.40
Output  | 0.00015573 | 0.00015573 | 0.00015573 |   0.0 |  0.00
Modify  | 0.3692     | 0.3692     | 0.3692     |   0.0 |  1.21
Other   |            | 0.06426    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311716.0 ave      311716 max      311716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311716
Ave neighs/atom = 155.85800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.689352606095, Press = 5.42259901275374
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7140.7412   -7140.7412   -7210.9903   -7210.9903    271.87157    271.87157    23523.518    23523.518   -1692.2532   -1692.2532 
   25000   -7139.6953   -7139.6953   -7208.0986   -7208.0986    264.72776    264.72776    23479.768    23479.768    66.254931    66.254931 
Loop time of 30.7613 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.809 ns/day, 8.545 hours/ns, 32.508 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.198     | 30.198     | 30.198     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.40
Output  | 0.00015793 | 0.00015793 | 0.00015793 |   0.0 |  0.00
Modify  | 0.37564    | 0.37564    | 0.37564    |   0.0 |  1.22
Other   |            | 0.06498    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311306.0 ave      311306 max      311306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311306
Ave neighs/atom = 155.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.759311279347, Press = 1.83080593099847
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -7139.6953   -7139.6953   -7208.0986   -7208.0986    264.72776    264.72776    23479.768    23479.768    66.254931    66.254931 
   26000   -7139.7882   -7139.7882   -7209.7886   -7209.7886    270.90849    270.90849    23513.034    23513.034   -1114.9292   -1114.9292 
Loop time of 30.8109 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.804 ns/day, 8.559 hours/ns, 32.456 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.254     | 30.254     | 30.254     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12023    | 0.12023    | 0.12023    |   0.0 |  0.39
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.37258    | 0.37258    | 0.37258    |   0.0 |  1.21
Other   |            | 0.06403    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312024.0 ave      312024 max      312024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312024
Ave neighs/atom = 156.01200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.798649263096, Press = 5.519875509258
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7139.7882   -7139.7882   -7209.7886   -7209.7886    270.90849    270.90849    23513.034    23513.034   -1114.9292   -1114.9292 
   27000   -7141.7153   -7141.7153   -7212.4832   -7212.4832    273.87902    273.87902    23487.814    23487.814    313.41509    313.41509 
Loop time of 30.4116 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.841 ns/day, 8.448 hours/ns, 32.882 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    | 29.861     | 29.861     | 29.861     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11998    | 0.11998    | 0.11998    |   0.0 |  0.39
Output  | 0.00014833 | 0.00014833 | 0.00014833 |   0.0 |  0.00
Modify  | 0.36621    | 0.36621    | 0.36621    |   0.0 |  1.20
Other   |            | 0.06397    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311670.0 ave      311670 max      311670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311670
Ave neighs/atom = 155.83500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.710403814179, Press = 1.87363284052781
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7141.7153   -7141.7153   -7212.4832   -7212.4832    273.87902    273.87902    23487.814    23487.814    313.41509    313.41509 
   28000   -7139.0354   -7139.0354   -7209.1943   -7209.1943    271.52247    271.52247    23524.792    23524.792   -2574.3794   -2574.3794 
Loop time of 30.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.808 ns/day, 8.547 hours/ns, 32.499 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.216     | 30.216     | 30.216     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12073    | 0.12073    | 0.12073    |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.36869    | 0.36869    | 0.36869    |   0.0 |  1.20
Other   |            | 0.06408    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312054.0 ave      312054 max      312054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312054
Ave neighs/atom = 156.02700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.722491463153, Press = 4.53183223691542
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7139.0354   -7139.0354   -7209.1943   -7209.1943    271.52247    271.52247    23524.792    23524.792   -2574.3794   -2574.3794 
   29000   -7142.5062   -7142.5062   -7210.4408   -7210.4408     262.9138     262.9138    23483.101    23483.101    1144.8163    1144.8163 
Loop time of 30.0912 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.871 ns/day, 8.359 hours/ns, 33.232 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    | 29.542     | 29.542     | 29.542     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11909    | 0.11909    | 0.11909    |   0.0 |  0.40
Output  | 0.00019848 | 0.00019848 | 0.00019848 |   0.0 |  0.00
Modify  | 0.36538    | 0.36538    | 0.36538    |   0.0 |  1.21
Other   |            | 0.06408    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311642.0 ave      311642 max      311642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311642
Ave neighs/atom = 155.82100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.656776854163, Press = 6.53338582289812
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -7142.5062   -7142.5062   -7210.4408   -7210.4408     262.9138     262.9138    23483.101    23483.101    1144.8163    1144.8163 
   30000   -7136.9544   -7136.9544   -7209.0275   -7209.0275    278.93032    278.93032    23484.171    23484.171    1445.2565    1445.2565 
Loop time of 30.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.846 ns/day, 8.432 hours/ns, 32.945 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    | 29.801     | 29.801     | 29.801     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11934    | 0.11934    | 0.11934    |   0.0 |  0.39
Output  | 0.00015156 | 0.00015156 | 0.00015156 |   0.0 |  0.00
Modify  | 0.36871    | 0.36871    | 0.36871    |   0.0 |  1.21
Other   |            | 0.06452    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5136.00 ave        5136 max        5136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311854.0 ave      311854 max      311854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311854
Ave neighs/atom = 155.92700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.678020711596, Press = 0.421118602234636
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7136.9544   -7136.9544   -7209.0275   -7209.0275    278.93032    278.93032    23484.171    23484.171    1445.2565    1445.2565 
   31000   -7140.9277   -7140.9277   -7210.8695   -7210.8695    270.68214    270.68214    23514.027    23514.027   -857.13535   -857.13535 
Loop time of 30.4212 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.840 ns/day, 8.450 hours/ns, 32.872 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.873     | 29.873     | 29.873     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1198     | 0.1198     | 0.1198     |   0.0 |  0.39
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.36484    | 0.36484    | 0.36484    |   0.0 |  1.20
Other   |            | 0.06339    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311870.0 ave      311870 max      311870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311870
Ave neighs/atom = 155.93500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.7702713759, Press = 1.74449691382473
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7140.9277   -7140.9277   -7210.8695   -7210.8695    270.68214    270.68214    23514.027    23514.027   -857.13535   -857.13535 
   32000   -7139.4026   -7139.4026   -7210.3923   -7210.3923    274.73773    274.73773    23493.534    23493.534    603.25439    603.25439 
Loop time of 30.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.867 ns/day, 8.372 hours/ns, 33.181 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    | 29.59      | 29.59      | 29.59      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11924    | 0.11924    | 0.11924    |   0.0 |  0.40
Output  | 0.00020941 | 0.00020941 | 0.00020941 |   0.0 |  0.00
Modify  | 0.36501    | 0.36501    | 0.36501    |   0.0 |  1.21
Other   |            | 0.06394    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5152.00 ave        5152 max        5152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311534.0 ave      311534 max      311534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311534
Ave neighs/atom = 155.76700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.823725203362, Press = 4.5876042873432
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -7139.4026   -7139.4026   -7210.3923   -7210.3923    274.73773    274.73773    23493.534    23493.534    603.25439    603.25439 
   33000   -7136.9544   -7136.9544   -7208.4696   -7208.4696    276.77125    276.77125    23498.792    23498.792    258.37641    258.37641 
Loop time of 30.1166 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.869 ns/day, 8.366 hours/ns, 33.204 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    | 29.566     | 29.566     | 29.566     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1186     | 0.1186     | 0.1186     |   0.0 |  0.39
Output  | 0.00015112 | 0.00015112 | 0.00015112 |   0.0 |  0.00
Modify  | 0.36744    | 0.36744    | 0.36744    |   0.0 |  1.22
Other   |            | 0.06436    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5140.00 ave        5140 max        5140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311598.0 ave      311598 max      311598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311598
Ave neighs/atom = 155.79900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.893613752422, Press = 2.18232684570426
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -7136.9544   -7136.9544   -7208.4696   -7208.4696    276.77125    276.77125    23498.792    23498.792    258.37641    258.37641 
   34000   -7141.0339   -7141.0339   -7212.5658   -7212.5658     276.8359     276.8359    23508.152    23508.152   -1307.3718   -1307.3718 
Loop time of 31.9337 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.706 ns/day, 8.870 hours/ns, 31.315 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.354     | 31.354     | 31.354     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12434    | 0.12434    | 0.12434    |   0.0 |  0.39
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.3909     | 0.3909     | 0.3909     |   0.0 |  1.22
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5139.00 ave        5139 max        5139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 155.85100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943775439142, Press = 2.5741262244111
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7141.0339   -7141.0339   -7212.5658   -7212.5658     276.8359     276.8359    23508.152    23508.152   -1307.3718   -1307.3718 
   35000   -7142.4875   -7142.4875   -7211.3527   -7211.3527    266.51516    266.51516    23461.839    23461.839     2889.858     2889.858 
Loop time of 30.737 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.811 ns/day, 8.538 hours/ns, 32.534 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.172     | 30.172     | 30.172     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11857    | 0.11857    | 0.11857    |   0.0 |  0.39
Output  | 0.00015178 | 0.00015178 | 0.00015178 |   0.0 |  0.00
Modify  | 0.38266    | 0.38266    | 0.38266    |   0.0 |  1.24
Other   |            | 0.06363    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5140.00 ave        5140 max        5140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311508.0 ave      311508 max      311508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311508
Ave neighs/atom = 155.75400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.971659132034, Press = 3.91213901894897
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -7142.4875   -7142.4875   -7211.3527   -7211.3527    266.51516    266.51516    23461.839    23461.839     2889.858     2889.858 
   36000   -7140.9303   -7140.9303   -7211.5985   -7211.5985     273.4931     273.4931    23492.489    23492.489    422.64249    422.64249 
Loop time of 31.0149 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.786 ns/day, 8.615 hours/ns, 32.243 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.451     | 30.451     | 30.451     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12208    | 0.12208    | 0.12208    |   0.0 |  0.39
Output  | 0.00020348 | 0.00020348 | 0.00020348 |   0.0 |  0.00
Modify  | 0.37722    | 0.37722    | 0.37722    |   0.0 |  1.22
Other   |            | 0.0647     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312094.0 ave      312094 max      312094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312094
Ave neighs/atom = 156.04700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.984028537765, Press = 0.458967987755664
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7140.9303   -7140.9303   -7211.5985   -7211.5985     273.4931     273.4931    23492.489    23492.489    422.64249    422.64249 
   37000   -7139.3684   -7139.3684   -7211.2767   -7211.2767    278.29263    278.29263    23544.669    23544.669   -4574.5717   -4574.5717 
Loop time of 30.6051 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.823 ns/day, 8.501 hours/ns, 32.674 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.045     | 30.045     | 30.045     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12072    | 0.12072    | 0.12072    |   0.0 |  0.39
Output  | 0.00019625 | 0.00019625 | 0.00019625 |   0.0 |  0.00
Modify  | 0.37446    | 0.37446    | 0.37446    |   0.0 |  1.22
Other   |            | 0.06479    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311762.0 ave      311762 max      311762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311762
Ave neighs/atom = 155.88100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.004902789921, Press = 1.01505841317969
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7139.3684   -7139.3684   -7211.2767   -7211.2767    278.29263    278.29263    23544.669    23544.669   -4574.5717   -4574.5717 
   38000   -7139.8072   -7139.8072    -7211.559    -7211.559    277.68707    277.68707    23483.378    23483.378      1134.41      1134.41 
Loop time of 31.5346 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.760 hours/ns, 31.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.964     | 30.964     | 30.964     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.39
Output  | 0.00015527 | 0.00015527 | 0.00015527 |   0.0 |  0.00
Modify  | 0.38319    | 0.38319    | 0.38319    |   0.0 |  1.22
Other   |            | 0.06504    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5148.00 ave        5148 max        5148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311078.0 ave      311078 max      311078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311078
Ave neighs/atom = 155.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 = 272.933103153221, Press = 2.42281184568361
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7139.8072   -7139.8072    -7211.559    -7211.559    277.68707    277.68707    23483.378    23483.378      1134.41      1134.41 
   39000   -7141.9109   -7141.9109   -7212.0196   -7212.0196    271.32791    271.32791    23481.998    23481.998    619.87677    619.87677 
Loop time of 31.131 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.775 ns/day, 8.647 hours/ns, 32.122 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.563     | 30.563     | 30.563     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12284    | 0.12284    | 0.12284    |   0.0 |  0.39
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.38144    | 0.38144    | 0.38144    |   0.0 |  1.23
Other   |            | 0.06401    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311860.0 ave      311860 max      311860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311860
Ave neighs/atom = 155.93000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.925373326277, Press = 4.70323669746822
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7141.9109   -7141.9109   -7212.0196   -7212.0196    271.32791    271.32791    23481.998    23481.998    619.87677    619.87677 
   40000   -7141.8936   -7141.8936   -7211.5752   -7211.5752     269.6749     269.6749    23502.226    23502.226   -343.61656   -343.61656 
Loop time of 29.7193 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.907 ns/day, 8.255 hours/ns, 33.648 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.172     | 29.172     | 29.172     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11795    | 0.11795    | 0.11795    |   0.0 |  0.40
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.3649     | 0.3649     | 0.3649     |   0.0 |  1.23
Other   |            | 0.06422    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5158.00 ave        5158 max        5158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311846.0 ave      311846 max      311846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311846
Ave neighs/atom = 155.92300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.971408166103, Press = 0.456252650761426
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -7141.8936   -7141.8936   -7211.5752   -7211.5752     269.6749     269.6749    23502.226    23502.226   -343.61656   -343.61656 
   41000   -7139.5598   -7139.5598   -7209.6624   -7209.6624    271.30415    271.30415    23509.297    23509.297    -1138.647    -1138.647 
Loop time of 30.5894 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.825 ns/day, 8.497 hours/ns, 32.691 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.026     | 30.026     | 30.026     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12227    | 0.12227    | 0.12227    |   0.0 |  0.40
Output  | 0.00015734 | 0.00015734 | 0.00015734 |   0.0 |  0.00
Modify  | 0.37603    | 0.37603    | 0.37603    |   0.0 |  1.23
Other   |            | 0.06456    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311702.0 ave      311702 max      311702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311702
Ave neighs/atom = 155.85100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.952983952253, Press = 2.23332017904489
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -7139.5598   -7139.5598   -7209.6624   -7209.6624    271.30415    271.30415    23509.297    23509.297    -1138.647    -1138.647 
   42000   -7140.5914   -7140.5914   -7212.9948   -7212.9948    280.20853    280.20853    23487.094    23487.094    100.66161    100.66161 
Loop time of 30.7789 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.807 ns/day, 8.550 hours/ns, 32.490 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.224     | 30.224     | 30.224     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11991    | 0.11991    | 0.11991    |   0.0 |  0.39
Output  | 0.00020441 | 0.00020441 | 0.00020441 |   0.0 |  0.00
Modify  | 0.37107    | 0.37107    | 0.37107    |   0.0 |  1.21
Other   |            | 0.06391    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5149.00 ave        5149 max        5149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311418.0 ave      311418 max      311418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311418
Ave neighs/atom = 155.70900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.890193414665, Press = 1.45922253140501
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7140.5914   -7140.5914   -7212.9948   -7212.9948    280.20853    280.20853    23487.094    23487.094    100.66161    100.66161 
   43000   -7139.8388   -7139.8388   -7210.9269   -7210.9269    275.11823    275.11823    23510.603    23510.603   -745.27254   -745.27254 
Loop time of 30.3911 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.843 ns/day, 8.442 hours/ns, 32.904 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.836     | 29.836     | 29.836     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12083    | 0.12083    | 0.12083    |   0.0 |  0.40
Output  | 0.00015374 | 0.00015374 | 0.00015374 |   0.0 |  0.00
Modify  | 0.36936    | 0.36936    | 0.36936    |   0.0 |  1.22
Other   |            | 0.06431    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311888.0 ave      311888 max      311888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311888
Ave neighs/atom = 155.94400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.860838863848, Press = 2.52559137902055
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -7139.8388   -7139.8388   -7210.9269   -7210.9269    275.11823    275.11823    23510.603    23510.603   -745.27254   -745.27254 
   44000   -7141.4356   -7141.4356   -7210.0154   -7210.0154    265.41057    265.41057    23491.656    23491.656    81.719207    81.719207 
Loop time of 30.8554 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.800 ns/day, 8.571 hours/ns, 32.409 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.291     | 30.291     | 30.291     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12202    | 0.12202    | 0.12202    |   0.0 |  0.40
Output  | 0.00015502 | 0.00015502 | 0.00015502 |   0.0 |  0.00
Modify  | 0.37765    | 0.37765    | 0.37765    |   0.0 |  1.22
Other   |            | 0.06482    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311554.0 ave      311554 max      311554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311554
Ave neighs/atom = 155.77700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857580844407, Press = 0.96346914992544
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7141.4356   -7141.4356   -7210.0154   -7210.0154    265.41057    265.41057    23491.656    23491.656    81.719207    81.719207 
   45000   -7140.0838   -7140.0838   -7212.0583   -7212.0583    278.54871    278.54871    23495.664    23495.664    104.25866    104.25866 
Loop time of 30.6827 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.816 ns/day, 8.523 hours/ns, 32.592 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.123     | 30.123     | 30.123     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.40
Output  | 0.00019482 | 0.00019482 | 0.00019482 |   0.0 |  0.00
Modify  | 0.37275    | 0.37275    | 0.37275    |   0.0 |  1.21
Other   |            | 0.06457    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5180.00 ave        5180 max        5180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311748.0 ave      311748 max      311748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311748
Ave neighs/atom = 155.87400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874369949263, Press = 2.9380664390022
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -7140.0838   -7140.0838   -7212.0583   -7212.0583    278.54871    278.54871    23495.664    23495.664    104.25866    104.25866 
   46000   -7136.3112   -7136.3112   -7210.0596   -7210.0596    285.41402    285.41402    23477.723    23477.723    1468.3006    1468.3006 
Loop time of 30.2808 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.853 ns/day, 8.411 hours/ns, 33.024 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    | 29.728     | 29.728     | 29.728     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11929    | 0.11929    | 0.11929    |   0.0 |  0.39
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.36882    | 0.36882    | 0.36882    |   0.0 |  1.22
Other   |            | 0.06449    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311660.0 ave      311660 max      311660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311660
Ave neighs/atom = 155.83000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.91572611358, Press = 1.69925266918125
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7136.3112   -7136.3112   -7210.0596   -7210.0596    285.41402    285.41402    23477.723    23477.723    1468.3006    1468.3006 
   47000    -7141.544    -7141.544     -7209.11     -7209.11    261.48756    261.48756    23534.414    23534.414   -2231.1617   -2231.1617 
Loop time of 30.5847 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.825 ns/day, 8.496 hours/ns, 32.696 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.029     | 30.029     | 30.029     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1204     | 0.1204     | 0.1204     |   0.0 |  0.39
Output  | 0.00014941 | 0.00014941 | 0.00014941 |   0.0 |  0.00
Modify  | 0.37104    | 0.37104    | 0.37104    |   0.0 |  1.21
Other   |            | 0.06409    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312044.0 ave      312044 max      312044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312044
Ave neighs/atom = 156.02200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.954386543604, Press = 0.97188568894719
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -7141.544    -7141.544     -7209.11     -7209.11    261.48756    261.48756    23534.414    23534.414   -2231.1617   -2231.1617 
   48000   -7141.8699   -7141.8699   -7211.0862   -7211.0862    267.87399    267.87399      23478.4      23478.4    581.44707    581.44707 
Loop time of 30.2452 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.857 ns/day, 8.401 hours/ns, 33.063 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    | 29.695     | 29.695     | 29.695     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11874    | 0.11874    | 0.11874    |   0.0 |  0.39
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.36778    | 0.36778    | 0.36778    |   0.0 |  1.22
Other   |            | 0.06376    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5144.00 ave        5144 max        5144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311262.0 ave      311262 max      311262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311262
Ave neighs/atom = 155.63100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.99665848453, Press = 1.27220979330378
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -7141.8699   -7141.8699   -7211.0862   -7211.0862    267.87399    267.87399      23478.4      23478.4    581.44707    581.44707 
   49000   -7138.6654   -7138.6654   -7211.1218   -7211.1218    280.41349    280.41349    23499.046    23499.046    163.19268    163.19268 
Loop time of 30.7796 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.807 ns/day, 8.550 hours/ns, 32.489 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.223     | 30.223     | 30.223     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12094    | 0.12094    | 0.12094    |   0.0 |  0.39
Output  | 0.00015265 | 0.00015265 | 0.00015265 |   0.0 |  0.00
Modify  | 0.37182    | 0.37182    | 0.37182    |   0.0 |  1.21
Other   |            | 0.06379    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311954.0 ave      311954 max      311954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311954
Ave neighs/atom = 155.97700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.035090038379, Press = 2.20385461209979
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7138.6654   -7138.6654   -7211.1218   -7211.1218    280.41349    280.41349    23499.046    23499.046    163.19268    163.19268 
   50000   -7139.5602   -7139.5602   -7211.2181   -7211.2181    277.32382    277.32382    23479.609    23479.609    1297.9478    1297.9478 
Loop time of 30.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.871 ns/day, 8.360 hours/ns, 33.226 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    | 29.548     | 29.548     | 29.548     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11903    | 0.11903    | 0.11903    |   0.0 |  0.40
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.36597    | 0.36597    | 0.36597    |   0.0 |  1.22
Other   |            | 0.06381    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5151.00 ave        5151 max        5151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311840.0 ave      311840 max      311840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311840
Ave neighs/atom = 155.92000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.020587375929, Press = 1.62893688711607
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7139.5602   -7139.5602   -7211.2181   -7211.2181    277.32382    277.32382    23479.609    23479.609    1297.9478    1297.9478 
   51000    -7142.738    -7142.738   -7212.6003   -7212.6003    270.37439    270.37439    23501.949    23501.949   -520.17921   -520.17921 
Loop time of 30.6657 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.817 ns/day, 8.518 hours/ns, 32.610 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.105     | 30.105     | 30.105     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12096    | 0.12096    | 0.12096    |   0.0 |  0.39
Output  | 0.00015135 | 0.00015135 | 0.00015135 |   0.0 |  0.00
Modify  | 0.37525    | 0.37525    | 0.37525    |   0.0 |  1.22
Other   |            | 0.0647     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311610.0 ave      311610 max      311610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311610
Ave neighs/atom = 155.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.007825857781, Press = -0.275637897368747
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000    -7142.738    -7142.738   -7212.6003   -7212.6003    270.37439    270.37439    23501.949    23501.949   -520.17921   -520.17921 
   52000   -7139.6569   -7139.6569   -7208.9151   -7208.9151    268.03609    268.03609    23494.117    23494.117   -552.49834   -552.49834 
Loop time of 30.4498 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.837 ns/day, 8.458 hours/ns, 32.841 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    | 29.895     | 29.895     | 29.895     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12061    | 0.12061    | 0.12061    |   0.0 |  0.40
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.36985    | 0.36985    | 0.36985    |   0.0 |  1.21
Other   |            | 0.06427    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311862.0 ave      311862 max      311862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311862
Ave neighs/atom = 155.93100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.996025233741, Press = 2.28685463641637
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7139.6569   -7139.6569   -7208.9151   -7208.9151    268.03609    268.03609    23494.117    23494.117   -552.49834   -552.49834 
   53000   -7143.2082   -7143.2082   -7213.3981   -7213.3981    271.64207    271.64207    23502.928    23502.928   -698.13469   -698.13469 
Loop time of 30.6324 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.821 ns/day, 8.509 hours/ns, 32.645 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.075     | 30.075     | 30.075     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12002    | 0.12002    | 0.12002    |   0.0 |  0.39
Output  | 0.00019956 | 0.00019956 | 0.00019956 |   0.0 |  0.00
Modify  | 0.37346    | 0.37346    | 0.37346    |   0.0 |  1.22
Other   |            | 0.0638     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311726.0 ave      311726 max      311726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311726
Ave neighs/atom = 155.86300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.950702042465, Press = 3.22098359109064
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7143.2082   -7143.2082   -7213.3981   -7213.3981    271.64207    271.64207    23502.928    23502.928   -698.13469   -698.13469 
   54000   -7140.6604   -7140.6604   -7212.0311   -7212.0311    276.21221    276.21221    23470.328    23470.328    2527.7562    2527.7562 
Loop time of 30.2593 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.855 ns/day, 8.405 hours/ns, 33.048 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    | 29.704     | 29.704     | 29.704     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11958    | 0.11958    | 0.11958    |   0.0 |  0.40
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.37102    | 0.37102    | 0.37102    |   0.0 |  1.23
Other   |            | 0.06442    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5136.00 ave        5136 max        5136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311472.0 ave      311472 max      311472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311472
Ave neighs/atom = 155.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.951365536494, Press = 1.98494563039661
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7140.6604   -7140.6604   -7212.0311   -7212.0311    276.21221    276.21221    23470.328    23470.328    2527.7562    2527.7562 
   55000   -7141.5828   -7141.5828   -7210.0914   -7210.0914    265.13538    265.13538    23509.684    23509.684   -1042.4568   -1042.4568 
Loop time of 30.1932 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.862 ns/day, 8.387 hours/ns, 33.120 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.641     | 29.641     | 29.641     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12035    | 0.12035    | 0.12035    |   0.0 |  0.40
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.36667    | 0.36667    | 0.36667    |   0.0 |  1.21
Other   |            | 0.06468    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5153.00 ave        5153 max        5153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312180.0 ave      312180 max      312180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312180
Ave neighs/atom = 156.09000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943300206358, Press = -0.166411164359513
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7141.5828   -7141.5828   -7210.0914   -7210.0914    265.13538    265.13538    23509.684    23509.684   -1042.4568   -1042.4568 
   56000   -7139.8177   -7139.8177    -7210.765    -7210.765    274.57359    274.57359    23507.852    23507.852   -817.85425   -817.85425 
Loop time of 30.5086 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.832 ns/day, 8.475 hours/ns, 32.778 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    | 29.948     | 29.948     | 29.948     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.40
Output  | 0.00042276 | 0.00042276 | 0.00042276 |   0.0 |  0.00
Modify  | 0.37247    | 0.37247    | 0.37247    |   0.0 |  1.22
Other   |            | 0.06441    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5173.00 ave        5173 max        5173 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311648.0 ave      311648 max      311648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311648
Ave neighs/atom = 155.82400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.97513890279, Press = 1.87281856017513
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -7139.8177   -7139.8177    -7210.765    -7210.765    274.57359    274.57359    23507.852    23507.852   -817.85425   -817.85425 
   57000   -7136.9991   -7136.9991   -7207.5523   -7207.5523    273.04826    273.04826    23496.096    23496.096    212.28605    212.28605 
Loop time of 29.9184 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.888 ns/day, 8.311 hours/ns, 33.424 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    | 29.369     | 29.369     | 29.369     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11856    | 0.11856    | 0.11856    |   0.0 |  0.40
Output  | 0.00015669 | 0.00015669 | 0.00015669 |   0.0 |  0.00
Modify  | 0.36624    | 0.36624    | 0.36624    |   0.0 |  1.22
Other   |            | 0.06415    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5136.00 ave        5136 max        5136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311548.0 ave      311548 max      311548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311548
Ave neighs/atom = 155.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.978231468965, Press = 2.23537162176811
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -7136.9991   -7136.9991   -7207.5523   -7207.5523    273.04826    273.04826    23496.096    23496.096    212.28605    212.28605 
   58000   -7140.8452   -7140.8452    -7213.304    -7213.304    280.42294    280.42294     23466.72     23466.72     2043.179     2043.179 
Loop time of 30.2116 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.860 ns/day, 8.392 hours/ns, 33.100 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    | 29.656     | 29.656     | 29.656     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.40
Output  | 0.00015237 | 0.00015237 | 0.00015237 |   0.0 |  0.00
Modify  | 0.36965    | 0.36965    | 0.36965    |   0.0 |  1.22
Other   |            | 0.06465    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311846.0 ave      311846 max      311846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311846
Ave neighs/atom = 155.92300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.025587487906, Press = 1.29942071446267
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -7140.8452   -7140.8452    -7213.304    -7213.304    280.42294    280.42294     23466.72     23466.72     2043.179     2043.179 
   59000   -7138.2362   -7138.2362   -7210.2707   -7210.2707    278.78117    278.78117    23530.545    23530.545   -1988.9993   -1988.9993 
Loop time of 30.5386 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.829 ns/day, 8.483 hours/ns, 32.745 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    | 29.976     | 29.976     | 29.976     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.40
Output  | 0.00017521 | 0.00017521 | 0.00017521 |   0.0 |  0.00
Modify  | 0.37544    | 0.37544    | 0.37544    |   0.0 |  1.23
Other   |            | 0.06481    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5167.00 ave        5167 max        5167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312264.0 ave      312264 max      312264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312264
Ave neighs/atom = 156.13200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.032559656886, Press = 0.422909074470207
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -7138.2362   -7138.2362   -7210.2707   -7210.2707    278.78117    278.78117    23530.545    23530.545   -1988.9993   -1988.9993 
   60000   -7139.6598   -7139.6598   -7210.2458   -7210.2458    273.17505    273.17505    23491.418    23491.418   -306.09692   -306.09692 
Loop time of 30.2926 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.852 ns/day, 8.415 hours/ns, 33.011 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.735     | 29.735     | 29.735     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.40
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.37155    | 0.37155    | 0.37155    |   0.0 |  1.23
Other   |            | 0.06451    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311352.0 ave      311352 max      311352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311352
Ave neighs/atom = 155.67600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.085026324538, Press = 2.82974517517447
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -7139.6598   -7139.6598   -7210.2458   -7210.2458    273.17505    273.17505    23491.418    23491.418   -306.09692   -306.09692 
   61000   -7138.6579   -7138.6579   -7209.1176   -7209.1176    272.68626    272.68626     23459.43     23459.43    2167.2025    2167.2025 
Loop time of 30.4516 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.837 ns/day, 8.459 hours/ns, 32.839 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.888     | 29.888     | 29.888     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.40
Output  | 0.00014936 | 0.00014936 | 0.00014936 |   0.0 |  0.00
Modify  | 0.37683    | 0.37683    | 0.37683    |   0.0 |  1.24
Other   |            | 0.06468    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5155.00 ave        5155 max        5155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311940.0 ave      311940 max      311940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311940
Ave neighs/atom = 155.97000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.094524654992, Press = 2.16926656164718
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -7138.6579   -7138.6579   -7209.1176   -7209.1176    272.68626    272.68626     23459.43     23459.43    2167.2025    2167.2025 
   62000   -7137.7164   -7137.7164   -7208.9746   -7208.9746    275.77653    275.77653    23499.101    23499.101    502.60593    502.60593 
Loop time of 30.1634 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.864 ns/day, 8.379 hours/ns, 33.153 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.611     | 29.611     | 29.611     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1196     | 0.1196     | 0.1196     |   0.0 |  0.40
Output  | 0.00015511 | 0.00015511 | 0.00015511 |   0.0 |  0.00
Modify  | 0.36794    | 0.36794    | 0.36794    |   0.0 |  1.22
Other   |            | 0.06488    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312220.0 ave      312220 max      312220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312220
Ave neighs/atom = 156.11000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.158363664739, Press = 0.214224241868428
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -7137.7164   -7137.7164   -7208.9746   -7208.9746    275.77653    275.77653    23499.101    23499.101    502.60593    502.60593 
   63000   -7140.0181   -7140.0181   -7211.0192   -7211.0192    274.78152    274.78152    23512.203    23512.203   -2062.8828   -2062.8828 
Loop time of 30.4668 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.836 ns/day, 8.463 hours/ns, 32.823 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.912     | 29.912     | 29.912     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11968    | 0.11968    | 0.11968    |   0.0 |  0.39
Output  | 0.00015949 | 0.00015949 | 0.00015949 |   0.0 |  0.00
Modify  | 0.37052    | 0.37052    | 0.37052    |   0.0 |  1.22
Other   |            | 0.06427    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5141.00 ave        5141 max        5141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311594.0 ave      311594 max      311594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311594
Ave neighs/atom = 155.79700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.163324038024, Press = 0.577192093430315
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -7140.0181   -7140.0181   -7211.0192   -7211.0192    274.78152    274.78152    23512.203    23512.203   -2062.8828   -2062.8828 
   64000   -7137.0736   -7137.0736   -7208.6302   -7208.6302    276.93142    276.93142     23550.55     23550.55   -4008.6701   -4008.6701 
Loop time of 30.5299 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.830 ns/day, 8.481 hours/ns, 32.755 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.971     | 29.971     | 29.971     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.40
Output  | 0.00015286 | 0.00015286 | 0.00015286 |   0.0 |  0.00
Modify  | 0.37308    | 0.37308    | 0.37308    |   0.0 |  1.22
Other   |            | 0.06452    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311456.0 ave      311456 max      311456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311456
Ave neighs/atom = 155.72800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.212322965194, Press = 2.28838868442921
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -7137.0736   -7137.0736   -7208.6302   -7208.6302    276.93142    276.93142     23550.55     23550.55   -4008.6701   -4008.6701 
   65000   -7138.0452   -7138.0452   -7208.8005   -7208.8005     273.8304     273.8304    23477.658    23477.658    1258.1242    1258.1242 
Loop time of 30.3948 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.843 ns/day, 8.443 hours/ns, 32.900 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    | 29.839     | 29.839     | 29.839     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12058    | 0.12058    | 0.12058    |   0.0 |  0.40
Output  | 0.00019236 | 0.00019236 | 0.00019236 |   0.0 |  0.00
Modify  | 0.37013    | 0.37013    | 0.37013    |   0.0 |  1.22
Other   |            | 0.06454    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5145.00 ave        5145 max        5145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311056.0 ave      311056 max      311056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311056
Ave neighs/atom = 155.52800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.213708293069, Press = 1.63315327396431
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -7138.0452   -7138.0452   -7208.8005   -7208.8005     273.8304     273.8304    23477.658    23477.658    1258.1242    1258.1242 
   66000   -7142.6633   -7142.6633   -7211.4069   -7211.4069    266.04489    266.04489    23497.063    23497.063    377.73592    377.73592 
Loop time of 30.0351 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.877 ns/day, 8.343 hours/ns, 33.294 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.484     | 29.484     | 29.484     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11939    | 0.11939    | 0.11939    |   0.0 |  0.40
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.36653    | 0.36653    | 0.36653    |   0.0 |  1.22
Other   |            | 0.06471    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5144.00 ave        5144 max        5144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311872.0 ave      311872 max      311872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311872
Ave neighs/atom = 155.93600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.211573491778, Press = 1.13732184693144
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -7142.6633   -7142.6633   -7211.4069   -7211.4069    266.04489    266.04489    23497.063    23497.063    377.73592    377.73592 
   67000    -7137.798    -7137.798    -7208.797    -7208.797    274.77374    274.77374    23508.262    23508.262   -1362.5122   -1362.5122 
Loop time of 30.6081 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.823 ns/day, 8.502 hours/ns, 32.671 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.043     | 30.043     | 30.043     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12192    | 0.12192    | 0.12192    |   0.0 |  0.40
Output  | 0.00020473 | 0.00020473 | 0.00020473 |   0.0 |  0.00
Modify  | 0.37883    | 0.37883    | 0.37883    |   0.0 |  1.24
Other   |            | 0.06464    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5145.00 ave        5145 max        5145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311856.0 ave      311856 max      311856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311856
Ave neighs/atom = 155.92800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.208148778026, Press = 0.62112029698852
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -7137.798    -7137.798    -7208.797    -7208.797    274.77374    274.77374    23508.262    23508.262   -1362.5122   -1362.5122 
   68000    -7144.507    -7144.507   -7211.5123   -7211.5123    259.31755    259.31755    23498.791    23498.791   -123.47971   -123.47971 
Loop time of 29.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.882 ns/day, 8.326 hours/ns, 33.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.422     | 29.422     | 29.422     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12065    | 0.12065    | 0.12065    |   0.0 |  0.40
Output  | 0.00015154 | 0.00015154 | 0.00015154 |   0.0 |  0.00
Modify  | 0.36758    | 0.36758    | 0.36758    |   0.0 |  1.23
Other   |            | 0.06449    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311410.0 ave      311410 max      311410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311410
Ave neighs/atom = 155.70500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.190782917933, Press = 2.69912453755808
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000    -7144.507    -7144.507   -7211.5123   -7211.5123    259.31755    259.31755    23498.791    23498.791   -123.47971   -123.47971 
   69000   -7139.0298   -7139.0298   -7209.7931   -7209.7931    273.86122    273.86122    23486.813    23486.813    853.04026    853.04026 
Loop time of 30.3327 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.848 ns/day, 8.426 hours/ns, 32.968 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.774     | 29.774     | 29.774     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12106    | 0.12106    | 0.12106    |   0.0 |  0.40
Output  | 0.00015567 | 0.00015567 | 0.00015567 |   0.0 |  0.00
Modify  | 0.37294    | 0.37294    | 0.37294    |   0.0 |  1.23
Other   |            | 0.06455    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311742.0 ave      311742 max      311742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311742
Ave neighs/atom = 155.87100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.16745094756, Press = 1.28048614594056
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -7139.0298   -7139.0298   -7209.7931   -7209.7931    273.86122    273.86122    23486.813    23486.813    853.04026    853.04026 
   70000   -7139.8346   -7139.8346    -7209.276    -7209.276    268.74526    268.74526     23510.16     23510.16   -488.30147   -488.30147 
Loop time of 30.7499 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.810 ns/day, 8.542 hours/ns, 32.520 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.176     | 30.176     | 30.176     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.40
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.38503    | 0.38503    | 0.38503    |   0.0 |  1.25
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:        5172.00 ave        5172 max        5172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312080.0 ave      312080 max      312080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312080
Ave neighs/atom = 156.04000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.159185619586, Press = 0.912174237499943
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -7139.8346   -7139.8346    -7209.276    -7209.276    268.74526    268.74526     23510.16     23510.16   -488.30147   -488.30147 
   71000   -7136.9821   -7136.9821   -7206.9803   -7206.9803    270.90035    270.90035     23501.47     23501.47    203.71082    203.71082 
Loop time of 30.2469 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.856 ns/day, 8.402 hours/ns, 33.061 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.69      | 29.69      | 29.69      |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12114    | 0.12114    | 0.12114    |   0.0 |  0.40
Output  | 0.00014915 | 0.00014915 | 0.00014915 |   0.0 |  0.00
Modify  | 0.37081    | 0.37081    | 0.37081    |   0.0 |  1.23
Other   |            | 0.06428    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5184.00 ave        5184 max        5184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311762.0 ave      311762 max      311762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311762
Ave neighs/atom = 155.88100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.165531426042, Press = 1.41055559194821
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -7136.9821   -7136.9821   -7206.9803   -7206.9803    270.90035    270.90035     23501.47     23501.47    203.71082    203.71082 
   72000   -7139.9882   -7139.9882   -7210.5147   -7210.5147    272.94486    272.94486    23475.068    23475.068    1331.9575    1331.9575 
Loop time of 29.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.884 ns/day, 8.322 hours/ns, 33.378 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.412     | 29.412     | 29.412     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11994    | 0.11994    | 0.11994    |   0.0 |  0.40
Output  | 0.00015184 | 0.00015184 | 0.00015184 |   0.0 |  0.00
Modify  | 0.36445    | 0.36445    | 0.36445    |   0.0 |  1.22
Other   |            | 0.06382    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311456.0 ave      311456 max      311456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311456
Ave neighs/atom = 155.72800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.209351849401, Press = 2.4374558995851
next a
jump SELF top
variable a loop 2000
run 1000
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -7139.9882   -7139.9882   -7210.5147   -7210.5147    272.94486    272.94486    23475.068    23475.068    1331.9575    1331.9575 
   73000   -7139.2091   -7139.2091   -7211.6694   -7211.6694      280.429      280.429    23480.951    23480.951    1148.6285    1148.6285 
Loop time of 30.3298 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.849 ns/day, 8.425 hours/ns, 32.971 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.775     | 29.775     | 29.775     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12001    | 0.12001    | 0.12001    |   0.0 |  0.40
Output  | 0.00015248 | 0.00015248 | 0.00015248 |   0.0 |  0.00
Modify  | 0.37045    | 0.37045    | 0.37045    |   0.0 |  1.22
Other   |            | 0.064      |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311816.0 ave      311816 max      311816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311816
Ave neighs/atom = 155.90800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
23495.4976442381

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0