# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.867570169270039*${_u_distance}
variable latticeconst_converted equal 2.867570169270039*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86757016927004
Lattice spacing in x,y,z = 2.8675702 2.8675702 2.8675702
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.675702 28.675702 28.675702)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.675702 28.675702 28.675702)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

variable temp_converted equal 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_427873955970_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8489.4197   -8489.4197   -8559.9992   -8559.9992       273.15       273.15    23579.911    23579.911    3197.1008    3197.1008 
    1000   -8420.3229   -8420.3229   -8490.8669   -8490.8669    273.01273    273.01273    23768.843    23768.843   -2.4176827   -2.4176827 
Loop time of 144.232 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.599 ns/day, 40.065 hours/ns, 6.933 timesteps/s
99.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.98     | 143.98     | 143.98     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040509   | 0.040509   | 0.040509   |   0.0 |  0.03
Output  | 0.00028022 | 0.00028022 | 0.00028022 |   0.0 |  0.00
Modify  | 0.18207    | 0.18207    | 0.18207    |   0.0 |  0.13
Other   |            | 0.0297     |            |       |  0.02

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

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8420.3229   -8420.3229   -8490.8669   -8490.8669    273.01273    273.01273    23768.843    23768.843   -2.4176827   -2.4176827 
    2000   -8417.7377   -8417.7377   -8487.1191   -8487.1191    268.51299    268.51299     23804.83     23804.83   -2211.0087   -2211.0087 
Loop time of 194.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.445 ns/day, 53.947 hours/ns, 5.149 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    | 193.89     | 193.89     | 193.89     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052409   | 0.052409   | 0.052409   |   0.0 |  0.03
Output  | 0.00022703 | 0.00022703 | 0.00022703 |   0.0 |  0.00
Modify  | 0.23279    | 0.23279    | 0.23279    |   0.0 |  0.12
Other   |            | 0.03712    |            |       |  0.02

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

Total # of neighbors = 239542
Ave neighs/atom = 119.77100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8417.7377   -8417.7377   -8487.1191   -8487.1191    268.51299    268.51299     23804.83     23804.83   -2211.0087   -2211.0087 
    3000    -8420.559    -8420.559   -8489.7778   -8489.7778    267.88394    267.88394    23771.976    23771.976   -116.12047   -116.12047 
Loop time of 257.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.440 hours/ns, 3.888 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    | 256.76     | 256.76     | 256.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068704   | 0.068704   | 0.068704   |   0.0 |  0.03
Output  | 0.00038403 | 0.00038403 | 0.00038403 |   0.0 |  0.00
Modify  | 0.30815    | 0.30815    | 0.30815    |   0.0 |  0.12
Other   |            | 0.04817    |            |       |  0.02

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

Total # of neighbors = 239132
Ave neighs/atom = 119.56600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -8420.559    -8420.559   -8489.7778   -8489.7778    267.88394    267.88394    23771.976    23771.976   -116.12047   -116.12047 
    4000   -8417.5363   -8417.5363   -8486.6817   -8486.6817    267.59981    267.59981    23754.631    23754.631    1400.0427    1400.0427 
Loop time of 247.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.350 ns/day, 68.642 hours/ns, 4.047 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    | 246.7      | 246.7      | 246.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066664   | 0.066664   | 0.066664   |   0.0 |  0.03
Output  | 0.00021066 | 0.00021066 | 0.00021066 |   0.0 |  0.00
Modify  | 0.29873    | 0.29873    | 0.29873    |   0.0 |  0.12
Other   |            | 0.04851    |            |       |  0.02

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

Total # of neighbors = 239304
Ave neighs/atom = 119.65200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8417.5363   -8417.5363   -8486.6817   -8486.6817    267.59981    267.59981    23754.631    23754.631    1400.0427    1400.0427 
    5000   -8421.0319   -8421.0319   -8490.3003   -8490.3003    268.07608    268.07608    23781.013    23781.013   -858.80684   -858.80684 
Loop time of 219.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.394 ns/day, 60.859 hours/ns, 4.564 timesteps/s
99.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 218.72     | 218.72     | 218.72     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059494   | 0.059494   | 0.059494   |   0.0 |  0.03
Output  | 8.727e-05  | 8.727e-05  | 8.727e-05  |   0.0 |  0.00
Modify  | 0.26934    | 0.26934    | 0.26934    |   0.0 |  0.12
Other   |            | 0.04697    |            |       |  0.02

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

Total # of neighbors = 239996
Ave neighs/atom = 119.99800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 268.883797634221, Press = 733.82835056314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8421.0319   -8421.0319   -8490.3003   -8490.3003    268.07608    268.07608    23781.013    23781.013   -858.80684   -858.80684 
    6000   -8420.4884   -8420.4884   -8488.7542   -8488.7542    264.19566    264.19566    23774.294    23774.294   -284.16721   -284.16721 
Loop time of 227.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.243 hours/ns, 4.392 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    | 227.27     | 227.27     | 227.27     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062752   | 0.062752   | 0.062752   |   0.0 |  0.03
Output  | 0.00015924 | 0.00015924 | 0.00015924 |   0.0 |  0.00
Modify  | 0.29539    | 0.29539    | 0.29539    |   0.0 |  0.13
Other   |            | 0.04811    |            |       |  0.02

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

Total # of neighbors = 239086
Ave neighs/atom = 119.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.048134215205, Press = 12.9752511924172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8420.4884   -8420.4884   -8488.7542   -8488.7542    264.19566    264.19566    23774.294    23774.294   -284.16721   -284.16721 
    7000   -8418.8951   -8418.8951   -8489.5317   -8489.5317    273.37091    273.37091    23753.008    23753.008    1222.4143    1222.4143 
Loop time of 239.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.361 ns/day, 66.548 hours/ns, 4.174 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    | 239.15     | 239.15     | 239.15     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067057   | 0.067057   | 0.067057   |   0.0 |  0.03
Output  | 0.00016729 | 0.00016729 | 0.00016729 |   0.0 |  0.00
Modify  | 0.30678    | 0.30678    | 0.30678    |   0.0 |  0.13
Other   |            | 0.05036    |            |       |  0.02

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

Total # of neighbors = 239500
Ave neighs/atom = 119.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.838459586678, Press = 12.590678399543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8418.8951   -8418.8951   -8489.5317   -8489.5317    273.37091    273.37091    23753.008    23753.008    1222.4143    1222.4143 
    8000    -8422.431    -8422.431   -8492.3861   -8492.3861    270.73351    270.73351    23753.936    23753.936    751.53333    751.53333 
Loop time of 220.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.393 ns/day, 61.145 hours/ns, 4.543 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.74     | 219.74     | 219.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059168   | 0.059168   | 0.059168   |   0.0 |  0.03
Output  | 0.00011118 | 0.00011118 | 0.00011118 |   0.0 |  0.00
Modify  | 0.27898    | 0.27898    | 0.27898    |   0.0 |  0.13
Other   |            | 0.04363    |            |       |  0.02

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

Total # of neighbors = 239684
Ave neighs/atom = 119.84200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328515778034, Press = 28.5479173846509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -8422.431    -8422.431   -8492.3861   -8492.3861    270.73351    270.73351    23753.936    23753.936    751.53333    751.53333 
    9000   -8413.0801   -8413.0801   -8486.8062   -8486.8062    285.32744    285.32744    23827.768    23827.768   -3362.7126   -3362.7126 
Loop time of 224.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.385 ns/day, 62.308 hours/ns, 4.458 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    | 223.92     | 223.92     | 223.92     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06104    | 0.06104    | 0.06104    |   0.0 |  0.03
Output  | 0.00035611 | 0.00035611 | 0.00035611 |   0.0 |  0.00
Modify  | 0.28731    | 0.28731    | 0.28731    |   0.0 |  0.13
Other   |            | 0.04491    |            |       |  0.02

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

Total # of neighbors = 239512
Ave neighs/atom = 119.75600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.611584338854, Press = 11.0470869400017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8413.0801   -8413.0801   -8486.8062   -8486.8062    285.32744    285.32744    23827.768    23827.768   -3362.7126   -3362.7126 
   10000    -8419.289    -8419.289   -8490.2685   -8490.2685    274.69819    274.69819    23775.848    23775.848   -395.20559   -395.20559 
Loop time of 157.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.638 hours/ns, 6.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.82     | 156.82     | 156.82     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043083   | 0.043083   | 0.043083   |   0.0 |  0.03
Output  | 0.00010074 | 0.00010074 | 0.00010074 |   0.0 |  0.00
Modify  | 0.20422    | 0.20422    | 0.20422    |   0.0 |  0.13
Other   |            | 0.03272    |            |       |  0.02

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

Total # of neighbors = 238698
Ave neighs/atom = 119.34900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990464245307, Press = -10.2083645250697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -8419.289    -8419.289   -8490.2685   -8490.2685    274.69819    274.69819    23775.848    23775.848   -395.20559   -395.20559 
   11000   -8418.9355   -8418.9355   -8490.0254   -8490.0254    275.12502    275.12502    23750.113    23750.113    1462.9108    1462.9108 
Loop time of 173.866 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.56     | 173.56     | 173.56     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047152   | 0.047152   | 0.047152   |   0.0 |  0.03
Output  | 0.00012413 | 0.00012413 | 0.00012413 |   0.0 |  0.00
Modify  | 0.22177    | 0.22177    | 0.22177    |   0.0 |  0.13
Other   |            | 0.03431    |            |       |  0.02

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

Total # of neighbors = 239378
Ave neighs/atom = 119.68900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.078137456844, Press = 9.80196085431809
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8418.9355   -8418.9355   -8490.0254   -8490.0254    275.12502    275.12502    23750.113    23750.113    1462.9108    1462.9108 
   12000   -8420.2393   -8420.2393   -8489.2697   -8489.2697    267.15512    267.15512    23779.406    23779.406   -576.30706   -576.30706 
Loop time of 216.419 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.399 ns/day, 60.116 hours/ns, 4.621 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 216.04     | 216.04     | 216.04     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058887   | 0.058887   | 0.058887   |   0.0 |  0.03
Output  | 0.00015295 | 0.00015295 | 0.00015295 |   0.0 |  0.00
Modify  | 0.27412    | 0.27412    | 0.27412    |   0.0 |  0.13
Other   |            | 0.04244    |            |       |  0.02

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

Total # of neighbors = 239900
Ave neighs/atom = 119.95000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.862216388664, Press = 10.8928042202713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8420.2393   -8420.2393   -8489.2697   -8489.2697    267.15512    267.15512    23779.406    23779.406   -576.30706   -576.30706 
   13000   -8421.9554   -8421.9554   -8490.9346   -8490.9346    266.95669    266.95669    23784.381    23784.381    -1087.882    -1087.882 
Loop time of 267.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.229 hours/ns, 3.742 timesteps/s
98.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 266.78     | 266.78     | 266.78     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070691   | 0.070691   | 0.070691   |   0.0 |  0.03
Output  | 0.00024509 | 0.00024509 | 0.00024509 |   0.0 |  0.00
Modify  | 0.33023    | 0.33023    | 0.33023    |   0.0 |  0.12
Other   |            | 0.04934    |            |       |  0.02

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

Total # of neighbors = 239166
Ave neighs/atom = 119.58300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.76062817902, Press = 1.62670677678674
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8421.9554   -8421.9554   -8490.9346   -8490.9346    266.95669    266.95669    23784.381    23784.381    -1087.882    -1087.882 
   14000   -8419.4773   -8419.4773   -8489.3274   -8489.3274    270.32731    270.32731    23739.935    23739.935    2252.6381    2252.6381 
Loop time of 271.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.318 ns/day, 75.475 hours/ns, 3.680 timesteps/s
98.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    | 271.26     | 271.26     | 271.26     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070975   | 0.070975   | 0.070975   |   0.0 |  0.03
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.33309    | 0.33309    | 0.33309    |   0.0 |  0.12
Other   |            | 0.04845    |            |       |  0.02

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

Total # of neighbors = 239096
Ave neighs/atom = 119.54800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.510960315425, Press = 3.06567579673108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8419.4773   -8419.4773   -8489.3274   -8489.3274    270.32731    270.32731    23739.935    23739.935    2252.6381    2252.6381 
   15000   -8421.2637   -8421.2637   -8491.2735   -8491.2735    270.94494    270.94494    23750.676    23750.676     1266.536     1266.536 
Loop time of 268.113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.322 ns/day, 74.476 hours/ns, 3.730 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    | 267.66     | 267.66     | 267.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07125    | 0.07125    | 0.07125    |   0.0 |  0.03
Output  | 0.00017672 | 0.00017672 | 0.00017672 |   0.0 |  0.00
Modify  | 0.33064    | 0.33064    | 0.33064    |   0.0 |  0.12
Other   |            | 0.04785    |            |       |  0.02

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

Total # of neighbors = 240092
Ave neighs/atom = 120.04600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.583754253443, Press = 16.1692476300215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8421.2637   -8421.2637   -8491.2735   -8491.2735    270.94494    270.94494    23750.676    23750.676     1266.536     1266.536 
   16000   -8420.0927   -8420.0927   -8491.0398   -8491.0398    274.57258    274.57258    23830.622    23830.622   -4317.3459   -4317.3459 
Loop time of 234.663 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.184 hours/ns, 4.261 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.26     | 234.26     | 234.26     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061807   | 0.061807   | 0.061807   |   0.0 |  0.03
Output  | 0.000152   | 0.000152   | 0.000152   |   0.0 |  0.00
Modify  | 0.29414    | 0.29414    | 0.29414    |   0.0 |  0.13
Other   |            | 0.04594    |            |       |  0.02

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

Total # of neighbors = 239546
Ave neighs/atom = 119.77300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.6265063932, Press = 5.47593474606534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8420.0927   -8420.0927   -8491.0398   -8491.0398    274.57258    274.57258    23830.622    23830.622   -4317.3459   -4317.3459 
   17000   -8419.0307   -8419.0307   -8489.9365   -8489.9365    274.41286    274.41286    23774.235    23774.235   -168.21976   -168.21976 
Loop time of 259.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.094 hours/ns, 3.853 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    | 259.1      | 259.1      | 259.1      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069591   | 0.069591   | 0.069591   |   0.0 |  0.03
Output  | 0.00015509 | 0.00015509 | 0.00015509 |   0.0 |  0.00
Modify  | 0.32222    | 0.32222    | 0.32222    |   0.0 |  0.12
Other   |            | 0.04756    |            |       |  0.02

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

Total # of neighbors = 238370
Ave neighs/atom = 119.18500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.727518743865, Press = 0.117950953920947
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8419.0307   -8419.0307   -8489.9365   -8489.9365    274.41286    274.41286    23774.235    23774.235   -168.21976   -168.21976 
   18000   -8418.2738   -8418.2738   -8489.8373   -8489.8373    276.95821    276.95821    23747.674    23747.674    1675.6074    1675.6074 
Loop time of 156.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.553 ns/day, 43.373 hours/ns, 6.404 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    | 155.87     | 155.87     | 155.87     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042599   | 0.042599   | 0.042599   |   0.0 |  0.03
Output  | 0.00015928 | 0.00015928 | 0.00015928 |   0.0 |  0.00
Modify  | 0.19635    | 0.19635    | 0.19635    |   0.0 |  0.13
Other   |            | 0.03492    |            |       |  0.02

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

Total # of neighbors = 239368
Ave neighs/atom = 119.68400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.60080117225, Press = 4.96343903826765
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8418.2738   -8418.2738   -8489.8373   -8489.8373    276.95821    276.95821    23747.674    23747.674    1675.6074    1675.6074 
   19000   -8419.0242   -8419.0242    -8488.532    -8488.532    269.00256    269.00256    23776.993    23776.993   -220.92322   -220.92322 
Loop time of 287.18 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.301 ns/day, 79.772 hours/ns, 3.482 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    | 286.7      | 286.7      | 286.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07449    | 0.07449    | 0.07449    |   0.0 |  0.03
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.35154    | 0.35154    | 0.35154    |   0.0 |  0.12
Other   |            | 0.04981    |            |       |  0.02

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

Total # of neighbors = 239876
Ave neighs/atom = 119.93800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.575275136335, Press = 6.75742395598951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8419.0242   -8419.0242    -8488.532    -8488.532    269.00256    269.00256    23776.993    23776.993   -220.92322   -220.92322 
   20000   -8418.8953   -8418.8953   -8488.8477   -8488.8477    270.72286    270.72286    23819.849    23819.849    -3239.578    -3239.578 
Loop time of 269.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.321 ns/day, 74.723 hours/ns, 3.717 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    | 268.55     | 268.55     | 268.55     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070537   | 0.070537   | 0.070537   |   0.0 |  0.03
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.33123    | 0.33123    | 0.33123    |   0.0 |  0.12
Other   |            | 0.04758    |            |       |  0.02

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

Total # of neighbors = 239370
Ave neighs/atom = 119.68500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.44843314931, Press = 1.57241871510482
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8418.8953   -8418.8953   -8488.8477   -8488.8477    270.72286    270.72286    23819.849    23819.849    -3239.578    -3239.578 
   21000   -8419.8545   -8419.8545   -8491.3422   -8491.3422    276.66485    276.66485    23746.479    23746.479    1594.2852    1594.2852 
Loop time of 272.315 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.317 ns/day, 75.643 hours/ns, 3.672 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 271.86     | 271.86     | 271.86     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.071847   | 0.071847   | 0.071847   |   0.0 |  0.03
Output  | 0.00015741 | 0.00015741 | 0.00015741 |   0.0 |  0.00
Modify  | 0.33503    | 0.33503    | 0.33503    |   0.0 |  0.12
Other   |            | 0.04888    |            |       |  0.02

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

Total # of neighbors = 238552
Ave neighs/atom = 119.27600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.475244148745, Press = -2.55291243949241
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8419.8545   -8419.8545   -8491.3422   -8491.3422    276.66485    276.66485    23746.479    23746.479    1594.2852    1594.2852 
   22000   -8417.4613   -8417.4613   -8489.8484   -8489.8484    280.14537    280.14537    23753.068    23753.068    1413.7244    1413.7244 
Loop time of 276.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.312 ns/day, 76.855 hours/ns, 3.614 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    | 276.21     | 276.21     | 276.21     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073022   | 0.073022   | 0.073022   |   0.0 |  0.03
Output  | 0.00015839 | 0.00015839 | 0.00015839 |   0.0 |  0.00
Modify  | 0.34408    | 0.34408    | 0.34408    |   0.0 |  0.12
Other   |            | 0.05171    |            |       |  0.02

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

Total # of neighbors = 239528
Ave neighs/atom = 119.76400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.683908736278, Press = 4.41456265368815
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8417.4613   -8417.4613   -8489.8484   -8489.8484    280.14537    280.14537    23753.068    23753.068    1413.7244    1413.7244 
   23000   -8418.5309   -8418.5309   -8488.2592   -8488.2592    269.85572    269.85572    23780.808    23780.808   -474.29381   -474.29381 
Loop time of 239.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.361 ns/day, 66.432 hours/ns, 4.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    | 238.75     | 238.75     | 238.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063784   | 0.063784   | 0.063784   |   0.0 |  0.03
Output  | 0.00015617 | 0.00015617 | 0.00015617 |   0.0 |  0.00
Modify  | 0.29919    | 0.29919    | 0.29919    |   0.0 |  0.13
Other   |            | 0.04557    |            |       |  0.02

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

Total # of neighbors = 239548
Ave neighs/atom = 119.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.776471198927, Press = 4.94927885026119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8418.5309   -8418.5309   -8488.2592   -8488.2592    269.85572    269.85572    23780.808    23780.808   -474.29381   -474.29381 
   24000    -8420.408    -8420.408   -8489.9596   -8489.9596    269.17205    269.17205    23788.592    23788.592   -1291.1167   -1291.1167 
Loop time of 238.171 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.363 ns/day, 66.159 hours/ns, 4.199 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    | 237.76     | 237.76     | 237.76     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064083   | 0.064083   | 0.064083   |   0.0 |  0.03
Output  | 0.00011945 | 0.00011945 | 0.00011945 |   0.0 |  0.00
Modify  | 0.29905    | 0.29905    | 0.29905    |   0.0 |  0.13
Other   |            | 0.04607    |            |       |  0.02

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

Total # of neighbors = 239346
Ave neighs/atom = 119.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.913268791458, Press = 2.07002983571322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -8420.408    -8420.408   -8489.9596   -8489.9596    269.17205    269.17205    23788.592    23788.592   -1291.1167   -1291.1167 
   25000   -8417.5773   -8417.5773   -8487.7676   -8487.7676     271.6438     271.6438    23755.546    23755.546     1373.183     1373.183 
Loop time of 250.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.345 ns/day, 69.594 hours/ns, 3.991 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    | 250.11     | 250.11     | 250.11     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067774   | 0.067774   | 0.067774   |   0.0 |  0.03
Output  | 0.00010637 | 0.00010637 | 0.00010637 |   0.0 |  0.00
Modify  | 0.31402    | 0.31402    | 0.31402    |   0.0 |  0.13
Other   |            | 0.04693    |            |       |  0.02

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

Total # of neighbors = 238988
Ave neighs/atom = 119.49400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.937990067342, Press = -0.137268940510303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8417.5773   -8417.5773   -8487.7676   -8487.7676     271.6438     271.6438    23755.546    23755.546     1373.183     1373.183 
   26000   -8416.8719   -8416.8719   -8487.3332   -8487.3332    272.69228    272.69228    23722.187    23722.187    3828.3588    3828.3588 
Loop time of 255.956 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.338 ns/day, 71.099 hours/ns, 3.907 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 255.51     | 255.51     | 255.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067881   | 0.067881   | 0.067881   |   0.0 |  0.03
Output  | 0.00011184 | 0.00011184 | 0.00011184 |   0.0 |  0.00
Modify  | 0.32935    | 0.32935    | 0.32935    |   0.0 |  0.13
Other   |            | 0.04692    |            |       |  0.02

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

Total # of neighbors = 239912
Ave neighs/atom = 119.95600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.963900089845, Press = 6.26580243251762
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8416.8719   -8416.8719   -8487.3332   -8487.3332    272.69228    272.69228    23722.187    23722.187    3828.3588    3828.3588 
   27000     -8422.82     -8422.82   -8490.2134   -8490.2134    260.81976    260.81976    23783.161    23783.161   -965.52597   -965.52597 
Loop time of 220.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.392 ns/day, 61.244 hours/ns, 4.536 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.1      | 220.1      | 220.1      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05936    | 0.05936    | 0.05936    |   0.0 |  0.03
Output  | 0.00014444 | 0.00014444 | 0.00014444 |   0.0 |  0.00
Modify  | 0.27796    | 0.27796    | 0.27796    |   0.0 |  0.13
Other   |            | 0.04343    |            |       |  0.02

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

Total # of neighbors = 240348
Ave neighs/atom = 120.17400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90686368291, Press = 4.32798304332075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000     -8422.82     -8422.82   -8490.2134   -8490.2134    260.81976    260.81976    23783.161    23783.161   -965.52597   -965.52597 
   28000   -8420.2362   -8420.2362   -8490.6483   -8490.6483    272.50214    272.50214    23784.457    23784.457   -1012.3539   -1012.3539 
Loop time of 252.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.342 ns/day, 70.204 hours/ns, 3.957 timesteps/s
97.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 252.32     | 252.32     | 252.32     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.065534   | 0.065534   | 0.065534   |   0.0 |  0.03
Output  | 0.0001815  | 0.0001815  | 0.0001815  |   0.0 |  0.00
Modify  | 0.30402    | 0.30402    | 0.30402    |   0.0 |  0.12
Other   |            | 0.04553    |            |       |  0.02

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

Total # of neighbors = 239014
Ave neighs/atom = 119.50700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918482492231, Press = 1.44669460401784
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8420.2362   -8420.2362   -8490.6483   -8490.6483    272.50214    272.50214    23784.457    23784.457   -1012.3539   -1012.3539 
   29000   -8417.3326   -8417.3326   -8487.6093   -8487.6093    271.97792    271.97792    23758.621    23758.621    1217.7828    1217.7828 
Loop time of 270.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.319 ns/day, 75.261 hours/ns, 3.691 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 270.49     | 270.49     | 270.49     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.070977   | 0.070977   | 0.070977   |   0.0 |  0.03
Output  | 0.00017068 | 0.00017068 | 0.00017068 |   0.0 |  0.00
Modify  | 0.33389    | 0.33389    | 0.33389    |   0.0 |  0.12
Other   |            | 0.04825    |            |       |  0.02

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

Total # of neighbors = 239054
Ave neighs/atom = 119.52700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.007898862236, Press = 1.67997436868565
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8417.3326   -8417.3326   -8487.6093   -8487.6093    271.97792    271.97792    23758.621    23758.621    1217.7828    1217.7828 
   30000   -8419.7954   -8419.7954   -8489.8676   -8489.8676    271.18657    271.18657    23758.234    23758.234    904.08346    904.08346 
Loop time of 283.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.305 ns/day, 78.665 hours/ns, 3.531 timesteps/s
99.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    | 282.73     | 282.73     | 282.73     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073787   | 0.073787   | 0.073787   |   0.0 |  0.03
Output  | 0.00019117 | 0.00019117 | 0.00019117 |   0.0 |  0.00
Modify  | 0.34083    | 0.34083    | 0.34083    |   0.0 |  0.12
Other   |            | 0.04889    |            |       |  0.02

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

Total # of neighbors = 239828
Ave neighs/atom = 119.91400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.058211150998, Press = 4.53763004435206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8419.7954   -8419.7954   -8489.8676   -8489.8676    271.18657    271.18657    23758.234    23758.234    904.08346    904.08346 
   31000   -8418.8571   -8418.8571   -8488.9563   -8488.9563     271.2909     271.2909    23825.682    23825.682   -3575.2722   -3575.2722 
Loop time of 257.159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.336 ns/day, 71.433 hours/ns, 3.889 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    | 256.72     | 256.72     | 256.72     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068534   | 0.068534   | 0.068534   |   0.0 |  0.03
Output  | 0.00019414 | 0.00019414 | 0.00019414 |   0.0 |  0.00
Modify  | 0.31864    | 0.31864    | 0.31864    |   0.0 |  0.12
Other   |            | 0.04703    |            |       |  0.02

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

Total # of neighbors = 239560
Ave neighs/atom = 119.78000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.092050211427, Press = 2.48169163962993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8418.8571   -8418.8571   -8488.9563   -8488.9563     271.2909     271.2909    23825.682    23825.682   -3575.2722   -3575.2722 
   32000   -8420.4928   -8420.4928   -8488.1451   -8488.1451    261.82137    261.82137    23769.442    23769.442    276.20594    276.20594 
Loop time of 216.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.398 ns/day, 60.247 hours/ns, 4.611 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 216.51     | 216.51     | 216.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059806   | 0.059806   | 0.059806   |   0.0 |  0.03
Output  | 0.00010686 | 0.00010686 | 0.00010686 |   0.0 |  0.00
Modify  | 0.27577    | 0.27577    | 0.27577    |   0.0 |  0.13
Other   |            | 0.04358    |            |       |  0.02

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

Total # of neighbors = 238264
Ave neighs/atom = 119.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.059975572987, Press = -0.227220601930293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8420.4928   -8420.4928   -8488.1451   -8488.1451    261.82137    261.82137    23769.442    23769.442    276.20594    276.20594 
   33000   -8416.8395   -8416.8395   -8487.9352   -8487.9352    275.14773    275.14773    23760.263    23760.263    1058.1424    1058.1424 
Loop time of 251.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.344 ns/day, 69.848 hours/ns, 3.977 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    | 251.01     | 251.01     | 251.01     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067673   | 0.067673   | 0.067673   |   0.0 |  0.03
Output  | 0.0001377  | 0.0001377  | 0.0001377  |   0.0 |  0.00
Modify  | 0.32637    | 0.32637    | 0.32637    |   0.0 |  0.13
Other   |            | 0.04796    |            |       |  0.02

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

Total # of neighbors = 239390
Ave neighs/atom = 119.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.107148244691, Press = 2.15912175817934
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8416.8395   -8416.8395   -8487.9352   -8487.9352    275.14773    275.14773    23760.263    23760.263    1058.1424    1058.1424 
   34000    -8421.816    -8421.816   -8488.7838   -8488.7838    259.17239    259.17239    23772.156    23772.156   -71.076126   -71.076126 
Loop time of 230.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.944 hours/ns, 4.344 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    | 229.8      | 229.8      | 229.8      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061268   | 0.061268   | 0.061268   |   0.0 |  0.03
Output  | 8.8786e-05 | 8.8786e-05 | 8.8786e-05 |   0.0 |  0.00
Modify  | 0.28846    | 0.28846    | 0.28846    |   0.0 |  0.13
Other   |            | 0.04407    |            |       |  0.02

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

Total # of neighbors = 239672
Ave neighs/atom = 119.83600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.109256258836, Press = 3.00752470465772
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -8421.816    -8421.816   -8488.7838   -8488.7838    259.17239    259.17239    23772.156    23772.156   -71.076126   -71.076126 
   35000   -8417.9731   -8417.9731   -8487.9362   -8487.9362     270.7642     270.7642    23795.427    23795.427   -1384.8472   -1384.8472 
Loop time of 153.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.561 ns/day, 42.756 hours/ns, 6.497 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 153.65     | 153.65     | 153.65     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041257   | 0.041257   | 0.041257   |   0.0 |  0.03
Output  | 0.00017124 | 0.00017124 | 0.00017124 |   0.0 |  0.00
Modify  | 0.19567    | 0.19567    | 0.19567    |   0.0 |  0.13
Other   |            | 0.0299     |            |       |  0.02

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

Total # of neighbors = 239400
Ave neighs/atom = 119.70000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.02924656809, Press = 1.77414182780526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8417.9731   -8417.9731   -8487.9362   -8487.9362     270.7642     270.7642    23795.427    23795.427   -1384.8472   -1384.8472 
   36000   -8421.3795   -8421.3795   -8491.8484   -8491.8484    272.72205    272.72205    23759.115    23759.115    617.19731    617.19731 
Loop time of 155.42 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.172 hours/ns, 6.434 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.15     | 155.15     | 155.15     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041489   | 0.041489   | 0.041489   |   0.0 |  0.03
Output  | 0.00010666 | 0.00010666 | 0.00010666 |   0.0 |  0.00
Modify  | 0.19652    | 0.19652    | 0.19652    |   0.0 |  0.13
Other   |            | 0.03039    |            |       |  0.02

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

Total # of neighbors = 239002
Ave neighs/atom = 119.50100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.987672705857, Press = -0.686628289258302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8421.3795   -8421.3795   -8491.8484   -8491.8484    272.72205    272.72205    23759.115    23759.115    617.19731    617.19731 
   37000   -8417.7501   -8417.7501   -8489.0486   -8489.0486    275.93264    275.93264    23727.464    23727.464    3238.3175    3238.3175 
Loop time of 146.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.727 hours/ns, 6.820 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    | 146.37     | 146.37     | 146.37     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039653   | 0.039653   | 0.039653   |   0.0 |  0.03
Output  | 9.8347e-05 | 9.8347e-05 | 9.8347e-05 |   0.0 |  0.00
Modify  | 0.18566    | 0.18566    | 0.18566    |   0.0 |  0.13
Other   |            | 0.02828    |            |       |  0.02

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

Total # of neighbors = 239312
Ave neighs/atom = 119.65600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930788970096, Press = 3.17674335438845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8417.7501   -8417.7501   -8489.0486   -8489.0486    275.93264    275.93264    23727.464    23727.464    3238.3175    3238.3175 
   38000   -8420.6682   -8420.6682   -8490.3576   -8490.3576    269.70509    269.70509    23779.829    23779.829   -612.14073   -612.14073 
Loop time of 157.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.833 hours/ns, 6.337 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    | 157.52     | 157.52     | 157.52     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042884   | 0.042884   | 0.042884   |   0.0 |  0.03
Output  | 0.00010332 | 0.00010332 | 0.00010332 |   0.0 |  0.00
Modify  | 0.20106    | 0.20106    | 0.20106    |   0.0 |  0.13
Other   |            | 0.03094    |            |       |  0.02

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

Total # of neighbors = 240340
Ave neighs/atom = 120.17000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.914494948306, Press = 2.85767698233291
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8420.6682   -8420.6682   -8490.3576   -8490.3576    269.70509    269.70509    23779.829    23779.829   -612.14073   -612.14073 
   39000   -8416.0719   -8416.0719   -8487.5745   -8487.5745    276.72212    276.72212    23782.483    23782.483   -411.07248   -411.07248 
Loop time of 174.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.458 hours/ns, 5.732 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.14     | 174.14     | 174.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047879   | 0.047879   | 0.047879   |   0.0 |  0.03
Output  | 8.3912e-05 | 8.3912e-05 | 8.3912e-05 |   0.0 |  0.00
Modify  | 0.22259    | 0.22259    | 0.22259    |   0.0 |  0.13
Other   |            | 0.03515    |            |       |  0.02

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

Total # of neighbors = 239006
Ave neighs/atom = 119.50300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.988968853077, Press = 1.16642724531098
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8416.0719   -8416.0719   -8487.5745   -8487.5745    276.72212    276.72212    23782.483    23782.483   -411.07248   -411.07248 
   40000    -8419.081    -8419.081   -8490.1096   -8490.1096    274.88788    274.88788    23756.349    23756.349    1009.8638    1009.8638 
Loop time of 149.876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.632 hours/ns, 6.672 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    | 149.61     | 149.61     | 149.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040305   | 0.040305   | 0.040305   |   0.0 |  0.03
Output  | 9.2562e-05 | 9.2562e-05 | 9.2562e-05 |   0.0 |  0.00
Modify  | 0.19092    | 0.19092    | 0.19092    |   0.0 |  0.13
Other   |            | 0.02986    |            |       |  0.02

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

Total # of neighbors = 239258
Ave neighs/atom = 119.62900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.003751140481, Press = 1.39128459561591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -8419.081    -8419.081   -8490.1096   -8490.1096    274.88788    274.88788    23756.349    23756.349    1009.8638    1009.8638 
   41000   -8419.6875   -8419.6875   -8489.5485   -8489.5485    270.36908    270.36908    23749.627    23749.627    1504.5591    1504.5591 
Loop time of 146.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.588 ns/day, 40.785 hours/ns, 6.811 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    | 146.57     | 146.57     | 146.57     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039646   | 0.039646   | 0.039646   |   0.0 |  0.03
Output  | 9.8718e-05 | 9.8718e-05 | 9.8718e-05 |   0.0 |  0.00
Modify  | 0.18613    | 0.18613    | 0.18613    |   0.0 |  0.13
Other   |            | 0.02841    |            |       |  0.02

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

Total # of neighbors = 239640
Ave neighs/atom = 119.82000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.034544574662, Press = 3.21406264492422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8419.6875   -8419.6875   -8489.5485   -8489.5485    270.36908    270.36908    23749.627    23749.627    1504.5591    1504.5591 
   42000   -8420.3167   -8420.3167    -8489.723    -8489.723    268.60967    268.60967    23822.981    23822.981   -3524.0931   -3524.0931 
Loop time of 142.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.590 hours/ns, 7.016 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.28     | 142.28     | 142.28     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038227   | 0.038227   | 0.038227   |   0.0 |  0.03
Output  | 0.00010442 | 0.00010442 | 0.00010442 |   0.0 |  0.00
Modify  | 0.17988    | 0.17988    | 0.17988    |   0.0 |  0.13
Other   |            | 0.02796    |            |       |  0.02

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

Total # of neighbors = 239848
Ave neighs/atom = 119.92400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.051177150125, Press = 2.49633469614228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8420.3167   -8420.3167    -8489.723    -8489.723    268.60967    268.60967    23822.981    23822.981   -3524.0931   -3524.0931 
   43000   -8416.8287   -8416.8287   -8488.9623   -8488.9623    279.16447    279.16447    23785.659    23785.659   -775.64562   -775.64562 
Loop time of 149.171 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.91     | 148.91     | 148.91     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040294   | 0.040294   | 0.040294   |   0.0 |  0.03
Output  | 0.00034462 | 0.00034462 | 0.00034462 |   0.0 |  0.00
Modify  | 0.1902     | 0.1902     | 0.1902     |   0.0 |  0.13
Other   |            | 0.03036    |            |       |  0.02

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

Total # of neighbors = 238418
Ave neighs/atom = 119.20900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.131402776196, Press = -0.424273282047224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8416.8287   -8416.8287   -8488.9623   -8488.9623    279.16447    279.16447    23785.659    23785.659   -775.64562   -775.64562 
   44000    -8419.107    -8419.107   -8490.1519   -8490.1519    274.95096    274.95096    23739.241    23739.241      2148.27      2148.27 
Loop time of 248.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.348 ns/day, 68.996 hours/ns, 4.026 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 247.96     | 247.96     | 247.96     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066555   | 0.066555   | 0.066555   |   0.0 |  0.03
Output  | 0.00024846 | 0.00024846 | 0.00024846 |   0.0 |  0.00
Modify  | 0.30942    | 0.30942    | 0.30942    |   0.0 |  0.12
Other   |            | 0.0469     |            |       |  0.02

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

Total # of neighbors = 239004
Ave neighs/atom = 119.50200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.14354968152, Press = 1.94006036842975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000    -8419.107    -8419.107   -8490.1519   -8490.1519    274.95096    274.95096    23739.241    23739.241      2148.27      2148.27 
   45000   -8421.9634   -8421.9634   -8490.5084   -8490.5084    265.27637    265.27637    23770.465    23770.465   -176.81436   -176.81436 
Loop time of 245.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.352 ns/day, 68.119 hours/ns, 4.078 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    | 244.81     | 244.81     | 244.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066      | 0.066      | 0.066      |   0.0 |  0.03
Output  | 0.00018318 | 0.00018318 | 0.00018318 |   0.0 |  0.00
Modify  | 0.30552    | 0.30552    | 0.30552    |   0.0 |  0.12
Other   |            | 0.0461     |            |       |  0.02

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

Total # of neighbors = 240004
Ave neighs/atom = 120.00200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.140876279262, Press = 3.06957449604696
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8421.9634   -8421.9634   -8490.5084   -8490.5084    265.27637    265.27637    23770.465    23770.465   -176.81436   -176.81436 
   46000   -8418.1151   -8418.1151   -8488.3593   -8488.3593    271.85232    271.85232    23802.921    23802.921   -2000.3121   -2000.3121 
Loop time of 247.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.349 ns/day, 68.862 hours/ns, 4.034 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    | 247.48     | 247.48     | 247.48     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.067087   | 0.067087   | 0.067087   |   0.0 |  0.03
Output  | 0.00010282 | 0.00010282 | 0.00010282 |   0.0 |  0.00
Modify  | 0.31058    | 0.31058    | 0.31058    |   0.0 |  0.13
Other   |            | 0.04724    |            |       |  0.02

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

Total # of neighbors = 239368
Ave neighs/atom = 119.68400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.096591838538, Press = 1.20282825118796
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8418.1151   -8418.1151   -8488.3593   -8488.3593    271.85232    271.85232    23802.921    23802.921   -2000.3121   -2000.3121 
   47000    -8422.092    -8422.092   -8489.9417   -8489.9417    262.58523    262.58523    23750.642    23750.642    1277.5671    1277.5671 
Loop time of 148.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.326 hours/ns, 6.722 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    | 148.51     | 148.51     | 148.51     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040429   | 0.040429   | 0.040429   |   0.0 |  0.03
Output  | 0.00016368 | 0.00016368 | 0.00016368 |   0.0 |  0.00
Modify  | 0.19114    | 0.19114    | 0.19114    |   0.0 |  0.13
Other   |            | 0.0312     |            |       |  0.02

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

Total # of neighbors = 238774
Ave neighs/atom = 119.38700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.084547630724, Press = 0.396266472081406
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -8422.092    -8422.092   -8489.9417   -8489.9417    262.58523    262.58523    23750.642    23750.642    1277.5671    1277.5671 
   48000   -8417.7061   -8417.7061   -8490.5906   -8490.5906    282.07047    282.07047    23732.134    23732.134    2714.2426    2714.2426 
Loop time of 147.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.862 hours/ns, 6.798 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 146.85     | 146.85     | 146.85     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039184   | 0.039184   | 0.039184   |   0.0 |  0.03
Output  | 9.4395e-05 | 9.4395e-05 | 9.4395e-05 |   0.0 |  0.00
Modify  | 0.18502    | 0.18502    | 0.18502    |   0.0 |  0.13
Other   |            | 0.02864    |            |       |  0.02

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

Total # of neighbors = 239838
Ave neighs/atom = 119.91900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.044273601422, Press = 2.88531146646277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8417.7061   -8417.7061   -8490.5906   -8490.5906    282.07047    282.07047    23732.134    23732.134    2714.2426    2714.2426 
   49000   -8422.9528   -8422.9528   -8489.4756   -8489.4756       257.45       257.45    23804.423    23804.423   -2458.6283   -2458.6283 
Loop time of 141.482 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.24     | 141.24     | 141.24     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038437   | 0.038437   | 0.038437   |   0.0 |  0.03
Output  | 0.00015882 | 0.00015882 | 0.00015882 |   0.0 |  0.00
Modify  | 0.17887    | 0.17887    | 0.17887    |   0.0 |  0.13
Other   |            | 0.02935    |            |       |  0.02

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

Total # of neighbors = 240072
Ave neighs/atom = 120.03600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013903274818, Press = 2.96952674665838
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8422.9528   -8422.9528   -8489.4756   -8489.4756       257.45       257.45    23804.423    23804.423   -2458.6283   -2458.6283 
   50000   -8418.1576   -8418.1576   -8492.0618   -8492.0618    286.01708    286.01708    23791.201    23791.201   -1494.9273   -1494.9273 
Loop time of 131.141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.428 hours/ns, 7.625 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    | 130.91     | 130.91     | 130.91     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036046   | 0.036046   | 0.036046   |   0.0 |  0.03
Output  | 9.7293e-05 | 9.7293e-05 | 9.7293e-05 |   0.0 |  0.00
Modify  | 0.16331    | 0.16331    | 0.16331    |   0.0 |  0.12
Other   |            | 0.02806    |            |       |  0.02

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

Total # of neighbors = 238832
Ave neighs/atom = 119.41600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.968602719998, Press = 0.770469905345395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8418.1576   -8418.1576   -8492.0618   -8492.0618    286.01708    286.01708    23791.201    23791.201   -1494.9273   -1494.9273 
   51000   -8421.9416   -8421.9416   -8489.9267   -8489.9267    263.10932    263.10932    23751.476    23751.476    1448.3411    1448.3411 
Loop time of 131.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.457 hours/ns, 7.619 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    | 131.02     | 131.02     | 131.02     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036065   | 0.036065   | 0.036065   |   0.0 |  0.03
Output  | 9.247e-05  | 9.247e-05  | 9.247e-05  |   0.0 |  0.00
Modify  | 0.16324    | 0.16324    | 0.16324    |   0.0 |  0.12
Other   |            | 0.02837    |            |       |  0.02

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

Total # of neighbors = 238654
Ave neighs/atom = 119.32700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941161441762, Press = 1.06651813333769
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8421.9416   -8421.9416   -8489.9267   -8489.9267    263.10932    263.10932    23751.476    23751.476    1448.3411    1448.3411 
   52000   -8418.0638   -8418.0638   -8489.4586   -8489.4586    276.30509    276.30509    23759.378    23759.378     1003.894     1003.894 
Loop time of 197.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.824 hours/ns, 5.067 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.03     | 197.03     | 197.03     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0535     | 0.0535     | 0.0535     |   0.0 |  0.03
Output  | 0.0001719  | 0.0001719  | 0.0001719  |   0.0 |  0.00
Modify  | 0.24712    | 0.24712    | 0.24712    |   0.0 |  0.13
Other   |            | 0.0397     |            |       |  0.02

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

Total # of neighbors = 239594
Ave neighs/atom = 119.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 = 272.926844264515, Press = 2.04920113233809
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8418.0638   -8418.0638   -8489.4586   -8489.4586    276.30509    276.30509    23759.378    23759.378     1003.894     1003.894 
   53000   -8423.7098   -8423.7098   -8491.9724   -8491.9724    264.18299    264.18299    23796.476    23796.476   -2072.2476   -2072.2476 
Loop time of 213.743 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.404 ns/day, 59.373 hours/ns, 4.679 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    | 213.36     | 213.36     | 213.36     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060021   | 0.060021   | 0.060021   |   0.0 |  0.03
Output  | 0.00025861 | 0.00025861 | 0.00025861 |   0.0 |  0.00
Modify  | 0.27766    | 0.27766    | 0.27766    |   0.0 |  0.13
Other   |            | 0.04841    |            |       |  0.02

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

Total # of neighbors = 239630
Ave neighs/atom = 119.81500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.889318788684, Press = 2.01707518459037
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8423.7098   -8423.7098   -8491.9724   -8491.9724    264.18299    264.18299    23796.476    23796.476   -2072.2476   -2072.2476 
   54000   -8418.0799   -8418.0799   -8489.0055   -8489.0055    274.48943    274.48943    23805.975    23805.975   -2253.5365   -2253.5365 
Loop time of 230.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.935 hours/ns, 4.345 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    | 229.77     | 229.77     | 229.77     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062813   | 0.062813   | 0.062813   |   0.0 |  0.03
Output  | 0.00016624 | 0.00016624 | 0.00016624 |   0.0 |  0.00
Modify  | 0.29152    | 0.29152    | 0.29152    |   0.0 |  0.13
Other   |            | 0.04539    |            |       |  0.02

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

Total # of neighbors = 238566
Ave neighs/atom = 119.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.878859385856, Press = -1.28167023308978
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8418.0799   -8418.0799   -8489.0055   -8489.0055    274.48943    274.48943    23805.975    23805.975   -2253.5365   -2253.5365 
   55000   -8418.6436   -8418.6436   -8488.4114   -8488.4114    270.00857    270.00857    23743.807    23743.807    2061.4597    2061.4597 
Loop time of 233.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 64.959 hours/ns, 4.276 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    | 233.45     | 233.45     | 233.45     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063485   | 0.063485   | 0.063485   |   0.0 |  0.03
Output  | 8.6349e-05 | 8.6349e-05 | 8.6349e-05 |   0.0 |  0.00
Modify  | 0.29279    | 0.29279    | 0.29279    |   0.0 |  0.13
Other   |            | 0.04534    |            |       |  0.02

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

Total # of neighbors = 238838
Ave neighs/atom = 119.41900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874478587456, Press = 1.24246172911225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8418.6436   -8418.6436   -8488.4114   -8488.4114    270.00857    270.00857    23743.807    23743.807    2061.4597    2061.4597 
   56000   -8421.5181   -8421.5181   -8489.8188   -8489.8188    264.33053    264.33053    23763.054    23763.054    459.25165    459.25165 
Loop time of 144.442 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 144.19     | 144.19     | 144.19     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038856   | 0.038856   | 0.038856   |   0.0 |  0.03
Output  | 0.00018106 | 0.00018106 | 0.00018106 |   0.0 |  0.00
Modify  | 0.18574    | 0.18574    | 0.18574    |   0.0 |  0.13
Other   |            | 0.02897    |            |       |  0.02

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

Total # of neighbors = 240058
Ave neighs/atom = 120.02900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.884562147811, Press = 2.13939146912329
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8421.5181   -8421.5181   -8489.8188   -8489.8188    264.33053    264.33053    23763.054    23763.054    459.25165    459.25165 
   57000   -8419.5285   -8419.5285   -8489.3542   -8489.3542     270.2328     270.2328    23799.808    23799.808   -1953.7485   -1953.7485 
Loop time of 141.759 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.51     | 141.51     | 141.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037845   | 0.037845   | 0.037845   |   0.0 |  0.03
Output  | 9.5268e-05 | 9.5268e-05 | 9.5268e-05 |   0.0 |  0.00
Modify  | 0.18076    | 0.18076    | 0.18076    |   0.0 |  0.13
Other   |            | 0.02773    |            |       |  0.02

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

Total # of neighbors = 239544
Ave neighs/atom = 119.77200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875308565113, Press = 1.33090108861838
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8419.5285   -8419.5285   -8489.3542   -8489.3542     270.2328     270.2328    23799.808    23799.808   -1953.7485   -1953.7485 
   58000   -8419.1701   -8419.1701   -8490.1978   -8490.1978     274.8845     274.8845    23768.668    23768.668    136.73465    136.73465 
Loop time of 155.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.554 ns/day, 43.317 hours/ns, 6.413 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    | 155.67     | 155.67     | 155.67     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042228   | 0.042228   | 0.042228   |   0.0 |  0.03
Output  | 9.6103e-05 | 9.6103e-05 | 9.6103e-05 |   0.0 |  0.00
Modify  | 0.19879    | 0.19879    | 0.19879    |   0.0 |  0.13
Other   |            | 0.03085    |            |       |  0.02

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

Total # of neighbors = 238782
Ave neighs/atom = 119.39100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87998774571, Press = -0.145206378934656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8419.1701   -8419.1701   -8490.1978   -8490.1978     274.8845     274.8845    23768.668    23768.668    136.73465    136.73465 
   59000   -8419.6345   -8419.6345   -8489.9178   -8489.9178    272.00349    272.00349     23722.86     23722.86    3478.0671    3478.0671 
Loop time of 148.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.189 hours/ns, 6.744 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.02     | 148.02     | 148.02     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040004   | 0.040004   | 0.040004   |   0.0 |  0.03
Output  | 9.9275e-05 | 9.9275e-05 | 9.9275e-05 |   0.0 |  0.00
Modify  | 0.19074    | 0.19074    | 0.19074    |   0.0 |  0.13
Other   |            | 0.02961    |            |       |  0.02

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

Total # of neighbors = 239266
Ave neighs/atom = 119.63300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875350989214, Press = 1.83427208601283
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8419.6345   -8419.6345   -8489.9178   -8489.9178    272.00349    272.00349     23722.86     23722.86    3478.0671    3478.0671 
   60000   -8420.2438   -8420.2438   -8490.1134   -8490.1134    270.40264    270.40264    23778.423    23778.423   -540.57914   -540.57914 
Loop time of 149.53 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.27     | 149.27     | 149.27     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040739   | 0.040739   | 0.040739   |   0.0 |  0.03
Output  | 8.1853e-05 | 8.1853e-05 | 8.1853e-05 |   0.0 |  0.00
Modify  | 0.18966    | 0.18966    | 0.18966    |   0.0 |  0.13
Other   |            | 0.03106    |            |       |  0.02

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

Total # of neighbors = 239942
Ave neighs/atom = 119.97100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.89371724678, Press = 2.10080070186832
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8420.2438   -8420.2438   -8490.1134   -8490.1134    270.40264    270.40264    23778.423    23778.423   -540.57914   -540.57914 
   61000   -8416.5367   -8416.5367    -8487.438    -8487.438    274.39546    274.39546    23792.324    23792.324   -1141.4995   -1141.4995 
Loop time of 217.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.397 ns/day, 60.380 hours/ns, 4.600 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    | 217        | 217        | 217        |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058368   | 0.058368   | 0.058368   |   0.0 |  0.03
Output  | 0.00032891 | 0.00032891 | 0.00032891 |   0.0 |  0.00
Modify  | 0.27151    | 0.27151    | 0.27151    |   0.0 |  0.12
Other   |            | 0.04224    |            |       |  0.02

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

Total # of neighbors = 239354
Ave neighs/atom = 119.67700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.902117466934, Press = 1.12756960116762
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8416.5367   -8416.5367    -8487.438    -8487.438    274.39546    274.39546    23792.324    23792.324   -1141.4995   -1141.4995 
   62000   -8420.3379   -8420.3379   -8489.7357   -8489.7357    268.57658    268.57658    23762.215    23762.215    718.24662    718.24662 
Loop time of 226.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.381 ns/day, 62.970 hours/ns, 4.411 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    | 226.3      | 226.3      | 226.3      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060915   | 0.060915   | 0.060915   |   0.0 |  0.03
Output  | 9.9729e-05 | 9.9729e-05 | 9.9729e-05 |   0.0 |  0.00
Modify  | 0.28366    | 0.28366    | 0.28366    |   0.0 |  0.13
Other   |            | 0.04394    |            |       |  0.02

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

Total # of neighbors = 239224
Ave neighs/atom = 119.61200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928865302627, Press = 0.779755270700013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8420.3379   -8420.3379   -8489.7357   -8489.7357    268.57658    268.57658    23762.215    23762.215    718.24662    718.24662 
   63000   -8415.8509   -8415.8509   -8488.7774   -8488.7774    282.23279    282.23279    23756.837    23756.837    1335.8494    1335.8494 
Loop time of 221.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.390 ns/day, 61.503 hours/ns, 4.517 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.03     | 221.03     | 221.03     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059624   | 0.059624   | 0.059624   |   0.0 |  0.03
Output  | 0.00015733 | 0.00015733 | 0.00015733 |   0.0 |  0.00
Modify  | 0.27676    | 0.27676    | 0.27676    |   0.0 |  0.12
Other   |            | 0.04284    |            |       |  0.02

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

Total # of neighbors = 239570
Ave neighs/atom = 119.78500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.96508382996, Press = 1.78241201378676
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8415.8509   -8415.8509   -8488.7774   -8488.7774    282.23279    282.23279    23756.837    23756.837    1335.8494    1335.8494 
   64000   -8419.7237   -8419.7237   -8489.8441   -8489.8441     271.3732     271.3732    23827.351    23827.351   -3824.4716   -3824.4716 
Loop time of 225.197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.555 hours/ns, 4.441 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    | 224.81     | 224.81     | 224.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059874   | 0.059874   | 0.059874   |   0.0 |  0.03
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.28173    | 0.28173    | 0.28173    |   0.0 |  0.13
Other   |            | 0.04405    |            |       |  0.02

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

Total # of neighbors = 239502
Ave neighs/atom = 119.75100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.006986891779, Press = 2.0049726918185
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8419.7237   -8419.7237   -8489.8441   -8489.8441     271.3732     271.3732    23827.351    23827.351   -3824.4716   -3824.4716 
   65000   -8415.3994   -8415.3994   -8487.8305   -8487.8305    280.31581    280.31581    23800.653    23800.653   -1595.0256   -1595.0256 
Loop time of 198.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.435 ns/day, 55.212 hours/ns, 5.031 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.41     | 198.41     | 198.41     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053968   | 0.053968   | 0.053968   |   0.0 |  0.03
Output  | 0.00014259 | 0.00014259 | 0.00014259 |   0.0 |  0.00
Modify  | 0.25552    | 0.25552    | 0.25552    |   0.0 |  0.13
Other   |            | 0.04225    |            |       |  0.02

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

Total # of neighbors = 238116
Ave neighs/atom = 119.05800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.035198286811, Press = -0.396415995702131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8415.3994   -8415.3994   -8487.8305   -8487.8305    280.31581    280.31581    23800.653    23800.653   -1595.0256   -1595.0256 
   66000   -8417.6852   -8417.6852   -8488.2365   -8488.2365     273.0407     273.0407    23738.513    23738.513    2577.4543    2577.4543 
Loop time of 156.421 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.552 ns/day, 43.450 hours/ns, 6.393 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.14     | 156.14     | 156.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043205   | 0.043205   | 0.043205   |   0.0 |  0.03
Output  | 8.4546e-05 | 8.4546e-05 | 8.4546e-05 |   0.0 |  0.00
Modify  | 0.20377    | 0.20377    | 0.20377    |   0.0 |  0.13
Other   |            | 0.03496    |            |       |  0.02

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

Total # of neighbors = 238872
Ave neighs/atom = 119.43600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033716528707, Press = 1.23292497024755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8417.6852   -8417.6852   -8488.2365   -8488.2365     273.0407     273.0407    23738.513    23738.513    2577.4543    2577.4543 
   67000   -8417.2313   -8417.2313   -8489.9488   -8489.9488    281.42426    281.42426    23769.524    23769.524    171.02206    171.02206 
Loop time of 146.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.742 hours/ns, 6.818 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    | 146.41     | 146.41     | 146.41     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039654   | 0.039654   | 0.039654   |   0.0 |  0.03
Output  | 0.00016583 | 0.00016583 | 0.00016583 |   0.0 |  0.00
Modify  | 0.18849    | 0.18849    | 0.18849    |   0.0 |  0.13
Other   |            | 0.02913    |            |       |  0.02

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

Total # of neighbors = 240032
Ave neighs/atom = 120.01600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.041706056093, Press = 1.8741085794509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8417.2313   -8417.2313   -8489.9488   -8489.9488    281.42426    281.42426    23769.524    23769.524    171.02206    171.02206 
   68000   -8419.0938   -8419.0938   -8489.3949   -8489.3949    272.07252    272.07252    23790.872    23790.872   -1233.2019   -1233.2019 
Loop time of 145.744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.593 ns/day, 40.484 hours/ns, 6.861 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    | 145.49     | 145.49     | 145.49     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039469   | 0.039469   | 0.039469   |   0.0 |  0.03
Output  | 0.00021812 | 0.00021812 | 0.00021812 |   0.0 |  0.00
Modify  | 0.18661    | 0.18661    | 0.18661    |   0.0 |  0.13
Other   |            | 0.02865    |            |       |  0.02

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

Total # of neighbors = 239414
Ave neighs/atom = 119.70700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.016951650093, Press = 1.55710025789848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8419.0938   -8419.0938   -8489.3949   -8489.3949    272.07252    272.07252    23790.872    23790.872   -1233.2019   -1233.2019 
   69000   -8420.5861   -8420.5861   -8491.3231   -8491.3231     273.7594     273.7594    23781.542    23781.542   -906.50972   -906.50972 
Loop time of 142.198 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.95     | 141.95     | 141.95     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038354   | 0.038354   | 0.038354   |   0.0 |  0.03
Output  | 0.000105   | 0.000105   | 0.000105   |   0.0 |  0.00
Modify  | 0.18382    | 0.18382    | 0.18382    |   0.0 |  0.13
Other   |            | 0.02808    |            |       |  0.02

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

Total # of neighbors = 238868
Ave neighs/atom = 119.43400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.036723751989, Press = 0.688496274531043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8420.5861   -8420.5861   -8491.3231   -8491.3231     273.7594     273.7594    23781.542    23781.542   -906.50972   -906.50972 
   70000   -8416.0545   -8416.0545   -8487.8133   -8487.8133    277.71408    277.71408    23728.193    23728.193    3333.4065    3333.4065 
Loop time of 157.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.791 hours/ns, 6.343 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.37     | 157.37     | 157.37     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043491   | 0.043491   | 0.043491   |   0.0 |  0.03
Output  | 9.7885e-05 | 9.7885e-05 | 9.7885e-05 |   0.0 |  0.00
Modify  | 0.20427    | 0.20427    | 0.20427    |   0.0 |  0.13
Other   |            | 0.03179    |            |       |  0.02

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

Total # of neighbors = 239100
Ave neighs/atom = 119.55000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.076474706885, Press = 1.05197835569683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8416.0545   -8416.0545   -8487.8133   -8487.8133    277.71408    277.71408    23728.193    23728.193    3333.4065    3333.4065 
   71000   -8419.2259   -8419.2259   -8490.5659   -8490.5659    276.09324    276.09324    23767.274    23767.274    203.51065    203.51065 
Loop time of 193.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.446 ns/day, 53.820 hours/ns, 5.161 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    | 193.41     | 193.41     | 193.41     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052745   | 0.052745   | 0.052745   |   0.0 |  0.03
Output  | 0.00011275 | 0.00011275 | 0.00011275 |   0.0 |  0.00
Modify  | 0.24567    | 0.24567    | 0.24567    |   0.0 |  0.13
Other   |            | 0.04111    |            |       |  0.02

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

Total # of neighbors = 240252
Ave neighs/atom = 120.12600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.089049302643, Press = 2.65815127743026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8419.2259   -8419.2259   -8490.5659   -8490.5659    276.09324    276.09324    23767.274    23767.274    203.51065    203.51065 
   72000   -8417.0719   -8417.0719   -8489.3814   -8489.3814    279.84524    279.84524    23804.873    23804.873   -2154.6945   -2154.6945 
Loop time of 155.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.173 hours/ns, 6.434 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    | 155.14     | 155.14     | 155.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042776   | 0.042776   | 0.042776   |   0.0 |  0.03
Output  | 9.97e-05   | 9.97e-05   | 9.97e-05   |   0.0 |  0.00
Modify  | 0.20059    | 0.20059    | 0.20059    |   0.0 |  0.13
Other   |            | 0.03442    |            |       |  0.02

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

Total # of neighbors = 239282
Ave neighs/atom = 119.64100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.129817186337, Press = 0.923255594184689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8417.0719   -8417.0719   -8489.3814   -8489.3814    279.84524    279.84524    23804.873    23804.873   -2154.6945   -2154.6945 
   73000   -8418.7712   -8418.7712   -8490.6317   -8490.6317    278.10759    278.10759    23764.894    23764.894    452.51379    452.51379 
Loop time of 137.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.629 ns/day, 38.168 hours/ns, 7.278 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.16     | 137.16     | 137.16     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038145   | 0.038145   | 0.038145   |   0.0 |  0.03
Output  | 0.0001504  | 0.0001504  | 0.0001504  |   0.0 |  0.00
Modify  | 0.17277    | 0.17277    | 0.17277    |   0.0 |  0.13
Other   |            | 0.0304     |            |       |  0.02

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

Total # of neighbors = 238758
Ave neighs/atom = 119.37900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.130098580688, Press = 0.666298461516935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8418.7712   -8418.7712   -8490.6317   -8490.6317    278.10759    278.10759    23764.894    23764.894    452.51379    452.51379 
   74000   -8420.2737   -8420.2737   -8490.1344   -8490.1344    270.36807    270.36807     23748.12     23748.12    1498.0225    1498.0225 
Loop time of 166.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.519 ns/day, 46.209 hours/ns, 6.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    | 166.06     | 166.06     | 166.06     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047036   | 0.047036   | 0.047036   |   0.0 |  0.03
Output  | 0.00010392 | 0.00010392 | 0.00010392 |   0.0 |  0.00
Modify  | 0.21059    | 0.21059    | 0.21059    |   0.0 |  0.13
Other   |            | 0.03479    |            |       |  0.02

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

Total # of neighbors = 239424
Ave neighs/atom = 119.71200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.132118854711, Press = 1.50117862798875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8420.2737   -8420.2737   -8490.1344   -8490.1344    270.36807    270.36807     23748.12     23748.12    1498.0225    1498.0225 
   75000   -8418.4086   -8418.4086   -8489.7271   -8489.7271    276.00974    276.00974    23792.623    23792.623   -1488.1436   -1488.1436 
Loop time of 169.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.131 hours/ns, 5.894 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    | 169.37     | 169.37     | 169.37     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048785   | 0.048785   | 0.048785   |   0.0 |  0.03
Output  | 9.309e-05  | 9.309e-05  | 9.309e-05  |   0.0 |  0.00
Modify  | 0.21708    | 0.21708    | 0.21708    |   0.0 |  0.13
Other   |            | 0.03621    |            |       |  0.02

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

Total # of neighbors = 239666
Ave neighs/atom = 119.83300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.122273666725, Press = 1.77785037138768
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8418.4086   -8418.4086   -8489.7271   -8489.7271    276.00974    276.00974    23792.623    23792.623   -1488.1436   -1488.1436 
   76000   -8419.2722   -8419.2722   -8490.2185   -8490.2185    274.56935    274.56935    23799.897    23799.897    -1972.123    -1972.123 
Loop time of 221.838 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.389 ns/day, 61.622 hours/ns, 4.508 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.46     | 221.46     | 221.46     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059692   | 0.059692   | 0.059692   |   0.0 |  0.03
Output  | 0.00015725 | 0.00015725 | 0.00015725 |   0.0 |  0.00
Modify  | 0.27616    | 0.27616    | 0.27616    |   0.0 |  0.12
Other   |            | 0.04383    |            |       |  0.02

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

Total # of neighbors = 239044
Ave neighs/atom = 119.52200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.140962880302, Press = 0.472364463351203
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8419.2722   -8419.2722   -8490.2185   -8490.2185    274.56935    274.56935    23799.897    23799.897    -1972.123    -1972.123 
   77000   -8416.9947   -8416.9947   -8490.2066   -8490.2066    283.33742    283.33742    23718.983    23718.983    3769.6233    3769.6233 
Loop time of 222.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.389 ns/day, 61.671 hours/ns, 4.504 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.63     | 221.63     | 221.63     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062327   | 0.062327   | 0.062327   |   0.0 |  0.03
Output  | 0.00023756 | 0.00023756 | 0.00023756 |   0.0 |  0.00
Modify  | 0.27957    | 0.27957    | 0.27957    |   0.0 |  0.13
Other   |            | 0.0432     |            |       |  0.02

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

Total # of neighbors = 238870
Ave neighs/atom = 119.43500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.144179389818, Press = 0.31829936977021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8416.9947   -8416.9947   -8490.2066   -8490.2066    283.33742    283.33742    23718.983    23718.983    3769.6233    3769.6233 
   78000   -8419.4791   -8419.4791   -8489.8723   -8489.8723    272.42867    272.42867    23749.921    23749.921    1431.9205    1431.9205 
Loop time of 210.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.411 ns/day, 58.444 hours/ns, 4.753 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    | 210.03     | 210.03     | 210.03     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059492   | 0.059492   | 0.059492   |   0.0 |  0.03
Output  | 0.00010821 | 0.00010821 | 0.00010821 |   0.0 |  0.00
Modify  | 0.2658     | 0.2658     | 0.2658     |   0.0 |  0.13
Other   |            | 0.0416     |            |       |  0.02

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

Total # of neighbors = 240398
Ave neighs/atom = 120.19900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.145051413136, Press = 2.22345386966502
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -8419.4791   -8419.4791   -8489.8723   -8489.8723    272.42867    272.42867    23749.921    23749.921    1431.9205    1431.9205 
   79000    -8418.394    -8418.394   -8488.0862   -8488.0862    269.71634    269.71634    23792.096    23792.096   -1182.0951   -1182.0951 
Loop time of 222.574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.388 ns/day, 61.826 hours/ns, 4.493 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    | 222.19     | 222.19     | 222.19     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.06229    | 0.06229    | 0.06229    |   0.0 |  0.03
Output  | 0.0001287  | 0.0001287  | 0.0001287  |   0.0 |  0.00
Modify  | 0.28071    | 0.28071    | 0.28071    |   0.0 |  0.13
Other   |            | 0.04432    |            |       |  0.02

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

Total # of neighbors = 239832
Ave neighs/atom = 119.91600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.151058327336, Press = 1.32222527265503
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000    -8418.394    -8418.394   -8488.0862   -8488.0862    269.71634    269.71634    23792.096    23792.096   -1182.0951   -1182.0951 
   80000   -8416.9826   -8416.9826   -8489.1101   -8489.1101    279.14087    279.14087    23772.504    23772.504    46.406367    46.406367 
Loop time of 273.687 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.316 ns/day, 76.024 hours/ns, 3.654 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    | 273.23     | 273.23     | 273.23     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072739   | 0.072739   | 0.072739   |   0.0 |  0.03
Output  | 0.00021352 | 0.00021352 | 0.00021352 |   0.0 |  0.00
Modify  | 0.33212    | 0.33212    | 0.33212    |   0.0 |  0.12
Other   |            | 0.048      |            |       |  0.02

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

Total # of neighbors = 239030
Ave neighs/atom = 119.51500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.197592413923, Press = 0.643008976194677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -8416.9826   -8416.9826   -8489.1101   -8489.1101    279.14087    279.14087    23772.504    23772.504    46.406367    46.406367 
   81000   -8419.8381   -8419.8381    -8488.884    -8488.884    267.21463    267.21463    23743.008    23743.008    2004.1398    2004.1398 
Loop time of 248.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.348 ns/day, 69.006 hours/ns, 4.025 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 247.99     | 247.99     | 247.99     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0799     | 0.0799     | 0.0799     |   0.0 |  0.03
Output  | 0.00030006 | 0.00030006 | 0.00030006 |   0.0 |  0.00
Modify  | 0.30996    | 0.30996    | 0.30996    |   0.0 |  0.12
Other   |            | 0.04697    |            |       |  0.02

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

Total # of neighbors = 239472
Ave neighs/atom = 119.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 = 273.19177552523, Press = 1.34961342761353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -8419.8381   -8419.8381    -8488.884    -8488.884    267.21463    267.21463    23743.008    23743.008    2004.1398    2004.1398 
   82000   -8418.6278   -8418.6278   -8487.5365   -8487.5365    266.68386    266.68386    23792.695    23792.695   -1218.1124   -1218.1124 
Loop time of 201.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.108 hours/ns, 4.951 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    | 201.63     | 201.63     | 201.63     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057876   | 0.057876   | 0.057876   |   0.0 |  0.03
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.25757    | 0.25757    | 0.25757    |   0.0 |  0.13
Other   |            | 0.04165    |            |       |  0.02

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

Total # of neighbors = 240004
Ave neighs/atom = 120.00200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.206058126571, Press = 2.38822391660329
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -8418.6278   -8418.6278   -8487.5365   -8487.5365    266.68386    266.68386    23792.695    23792.695   -1218.1124   -1218.1124 
   83000   -8417.6617   -8417.6617   -8488.3549   -8488.3549    273.58985    273.58985    23812.357    23812.357   -2599.9071   -2599.9071 
Loop time of 261.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.551 hours/ns, 3.829 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    | 260.75     | 260.75     | 260.75     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069293   | 0.069293   | 0.069293   |   0.0 |  0.03
Output  | 0.0001048  | 0.0001048  | 0.0001048  |   0.0 |  0.00
Modify  | 0.32034    | 0.32034    | 0.32034    |   0.0 |  0.12
Other   |            | 0.04702    |            |       |  0.02

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

Total # of neighbors = 239158
Ave neighs/atom = 119.57900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.188599120528, Press = 0.616018741661727
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -8417.6617   -8417.6617   -8488.3549   -8488.3549    273.58985    273.58985    23812.357    23812.357   -2599.9071   -2599.9071 
   84000   -8421.7931   -8421.7931   -8491.3578   -8491.3578    269.22241    269.22241    23755.608    23755.608    849.07166    849.07166 
Loop time of 193.45 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.736 hours/ns, 5.169 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    | 193.11     | 193.11     | 193.11     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056527   | 0.056527   | 0.056527   |   0.0 |  0.03
Output  | 9.7489e-05 | 9.7489e-05 | 9.7489e-05 |   0.0 |  0.00
Modify  | 0.24703    | 0.24703    | 0.24703    |   0.0 |  0.13
Other   |            | 0.04075    |            |       |  0.02

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

Total # of neighbors = 238652
Ave neighs/atom = 119.32600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.168296343293, Press = 0.914055346816548
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -8421.7931   -8421.7931   -8491.3578   -8491.3578    269.22241    269.22241    23755.608    23755.608    849.07166    849.07166 
   85000   -8418.7197   -8418.7197    -8490.558    -8490.558    278.02147    278.02147    23765.578    23765.578    367.31281    367.31281 
Loop time of 204.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.422 ns/day, 56.812 hours/ns, 4.889 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    | 204.16     | 204.16     | 204.16     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059429   | 0.059429   | 0.059429   |   0.0 |  0.03
Output  | 0.00016667 | 0.00016667 | 0.00016667 |   0.0 |  0.00
Modify  | 0.2605     | 0.2605     | 0.2605     |   0.0 |  0.13
Other   |            | 0.04231    |            |       |  0.02

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

Total # of neighbors = 239500
Ave neighs/atom = 119.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.144925917073, Press = 1.42165760257656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -8418.7197   -8418.7197    -8490.558    -8490.558    278.02147    278.02147    23765.578    23765.578    367.31281    367.31281 
   86000   -8420.6638   -8420.6638    -8491.296    -8491.296    273.35378    273.35378    23786.739    23786.739   -1224.7814   -1224.7814 
Loop time of 181.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.530 hours/ns, 5.497 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    | 181.59     | 181.59     | 181.59     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052033   | 0.052033   | 0.052033   |   0.0 |  0.03
Output  | 0.00017266 | 0.00017266 | 0.00017266 |   0.0 |  0.00
Modify  | 0.2309     | 0.2309     | 0.2309     |   0.0 |  0.13
Other   |            | 0.03783    |            |       |  0.02

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

Total # of neighbors = 239152
Ave neighs/atom = 119.57600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.139087414576, Press = 1.26984070252428
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8420.6638   -8420.6638    -8491.296    -8491.296    273.35378    273.35378    23786.739    23786.739   -1224.7814   -1224.7814 
   87000   -8418.4947   -8418.4947   -8489.1812   -8489.1812    273.56399    273.56399    23787.884    23787.884   -950.63168   -950.63168 
Loop time of 212.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.407 ns/day, 58.995 hours/ns, 4.709 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    | 212.01     | 212.01     | 212.01     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059798   | 0.059798   | 0.059798   |   0.0 |  0.03
Output  | 0.00010708 | 0.00010708 | 0.00010708 |   0.0 |  0.00
Modify  | 0.2672     | 0.2672     | 0.2672     |   0.0 |  0.13
Other   |            | 0.04234    |            |       |  0.02

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

Total # of neighbors = 238862
Ave neighs/atom = 119.43100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.138098664804, Press = 0.363413598853281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8418.4947   -8418.4947   -8489.1812   -8489.1812    273.56399    273.56399    23787.884    23787.884   -950.63168   -950.63168 
   88000   -8419.6028   -8419.6028   -8490.4825   -8490.4825    274.31193    274.31193    23726.516    23726.516    3085.0768    3085.0768 
Loop time of 228.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.446 hours/ns, 4.378 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    | 228.01     | 228.01     | 228.01     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063358   | 0.063358   | 0.063358   |   0.0 |  0.03
Output  | 0.00018343 | 0.00018343 | 0.00018343 |   0.0 |  0.00
Modify  | 0.28585    | 0.28585    | 0.28585    |   0.0 |  0.13
Other   |            | 0.04454    |            |       |  0.02

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

Total # of neighbors = 239032
Ave neighs/atom = 119.51600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.147655133187, Press = 0.836679171366444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8419.6028   -8419.6028   -8490.4825   -8490.4825    274.31193    274.31193    23726.516    23726.516    3085.0768    3085.0768 
   89000   -8417.5067   -8417.5067    -8489.647    -8489.647    279.19063    279.19063    23764.541    23764.541    602.45009    602.45009 
Loop time of 197.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.925 hours/ns, 5.057 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.38     | 197.38     | 197.38     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057526   | 0.057526   | 0.057526   |   0.0 |  0.03
Output  | 0.00010217 | 0.00010217 | 0.00010217 |   0.0 |  0.00
Modify  | 0.25366    | 0.25366    | 0.25366    |   0.0 |  0.13
Other   |            | 0.04106    |            |       |  0.02

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

Total # of neighbors = 240124
Ave neighs/atom = 120.06200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.136622484696, Press = 1.9119308220677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8417.5067   -8417.5067    -8489.647    -8489.647    279.19063    279.19063    23764.541    23764.541    602.45009    602.45009 
   90000   -8422.4629   -8422.4629   -8491.3259   -8491.3259    266.50703    266.50703    23786.764    23786.764   -1267.5196   -1267.5196 
Loop time of 210.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.410 ns/day, 58.476 hours/ns, 4.750 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    | 210.15     | 210.15     | 210.15     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058169   | 0.058169   | 0.058169   |   0.0 |  0.03
Output  | 0.00013993 | 0.00013993 | 0.00013993 |   0.0 |  0.00
Modify  | 0.26318    | 0.26318    | 0.26318    |   0.0 |  0.13
Other   |            | 0.04216    |            |       |  0.02

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

Total # of neighbors = 239570
Ave neighs/atom = 119.78500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.108441271943, Press = 1.13630718047749
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8422.4629   -8422.4629   -8491.3259   -8491.3259    266.50703    266.50703    23786.764    23786.764   -1267.5196   -1267.5196 
   91000   -8418.7093   -8418.7093   -8489.6122   -8489.6122    274.40145    274.40145    23776.043    23776.043   -291.58587   -291.58587 
Loop time of 217.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.397 ns/day, 60.525 hours/ns, 4.589 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    | 217.51     | 217.51     | 217.51     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061802   | 0.061802   | 0.061802   |   0.0 |  0.03
Output  | 0.00010829 | 0.00010829 | 0.00010829 |   0.0 |  0.00
Modify  | 0.27224    | 0.27224    | 0.27224    |   0.0 |  0.12
Other   |            | 0.04395    |            |       |  0.02

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

Total # of neighbors = 238990
Ave neighs/atom = 119.49500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.099384300176, Press = 0.906306463818835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -8418.7093   -8418.7093   -8489.6122   -8489.6122    274.40145    274.40145    23776.043    23776.043   -291.58587   -291.58587 
   92000   -8415.6908   -8415.6908   -8487.5481   -8487.5481    278.09505    278.09505    23776.212    23776.212    83.494151    83.494151 
Loop time of 185.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.467 ns/day, 51.412 hours/ns, 5.403 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    | 184.76     | 184.76     | 184.76     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051776   | 0.051776   | 0.051776   |   0.0 |  0.03
Output  | 0.00014013 | 0.00014013 | 0.00014013 |   0.0 |  0.00
Modify  | 0.23691    | 0.23691    | 0.23691    |   0.0 |  0.13
Other   |            | 0.03907    |            |       |  0.02

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

Total # of neighbors = 239274
Ave neighs/atom = 119.63700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.100691230194, Press = 0.893411847260002
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -8415.6908   -8415.6908   -8487.5481   -8487.5481    278.09505    278.09505    23776.212    23776.212    83.494151    83.494151 
   93000   -8420.0807   -8420.0807   -8491.2352   -8491.2352    275.37505    275.37505    23768.127    23768.127    37.189068    37.189068 
Loop time of 155.949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.554 ns/day, 43.319 hours/ns, 6.412 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    | 155.68     | 155.68     | 155.68     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042214   | 0.042214   | 0.042214   |   0.0 |  0.03
Output  | 9.4656e-05 | 9.4656e-05 | 9.4656e-05 |   0.0 |  0.00
Modify  | 0.19835    | 0.19835    | 0.19835    |   0.0 |  0.13
Other   |            | 0.03034    |            |       |  0.02

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

Total # of neighbors = 239138
Ave neighs/atom = 119.56900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.120807862509, Press = 0.880311347588729
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -8420.0807   -8420.0807   -8491.2352   -8491.2352    275.37505    275.37505    23768.127    23768.127    37.189068    37.189068 
   94000   -8414.4138   -8414.4138   -8485.0796   -8485.0796    273.48417    273.48417    23769.562    23769.562    801.03125    801.03125 
Loop time of 143.069 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.604 ns/day, 39.741 hours/ns, 6.990 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.82     | 142.82     | 142.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039107   | 0.039107   | 0.039107   |   0.0 |  0.03
Output  | 9.2862e-05 | 9.2862e-05 | 9.2862e-05 |   0.0 |  0.00
Modify  | 0.18081    | 0.18081    | 0.18081    |   0.0 |  0.13
Other   |            | 0.02847    |            |       |  0.02

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

Total # of neighbors = 239380
Ave neighs/atom = 119.69000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.145735061058, Press = 0.999771423514891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -8414.4138   -8414.4138   -8485.0796   -8485.0796    273.48417    273.48417    23769.562    23769.562    801.03125    801.03125 
   95000   -8420.9592   -8420.9592   -8489.7308   -8489.7308    266.15296    266.15296    23784.285    23784.285   -917.80339   -917.80339 
Loop time of 142.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.579 hours/ns, 7.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.24     | 142.24     | 142.24     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038628   | 0.038628   | 0.038628   |   0.0 |  0.03
Output  | 9.7585e-05 | 9.7585e-05 | 9.7585e-05 |   0.0 |  0.00
Modify  | 0.18136    | 0.18136    | 0.18136    |   0.0 |  0.13
Other   |            | 0.02886    |            |       |  0.02

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

Total # of neighbors = 239736
Ave neighs/atom = 119.86800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.156073719956, Press = 1.12920693082288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -8420.9592   -8420.9592   -8489.7308   -8489.7308    266.15296    266.15296    23784.285    23784.285   -917.80339   -917.80339 
   96000   -8416.7745   -8416.7745   -8488.3981   -8488.3981    277.19085    277.19085    23792.983    23792.983   -1176.6741   -1176.6741 
Loop time of 150.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.894 hours/ns, 6.631 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.56     | 150.56     | 150.56     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041129   | 0.041129   | 0.041129   |   0.0 |  0.03
Output  | 9.7822e-05 | 9.7822e-05 | 9.7822e-05 |   0.0 |  0.00
Modify  | 0.19021    | 0.19021    | 0.19021    |   0.0 |  0.13
Other   |            | 0.02961    |            |       |  0.02

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

Total # of neighbors = 239262
Ave neighs/atom = 119.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 = 273.158569416868, Press = 0.480322723893092
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -8416.7745   -8416.7745   -8488.3981   -8488.3981    277.19085    277.19085    23792.983    23792.983   -1176.6741   -1176.6741 
   97000   -8420.6945   -8420.6945   -8489.6708   -8489.6708    266.94531    266.94531    23736.602    23736.602    2406.5007    2406.5007 
Loop time of 153.205 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.94     | 152.94     | 152.94     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042251   | 0.042251   | 0.042251   |   0.0 |  0.03
Output  | 9.8881e-05 | 9.8881e-05 | 9.8881e-05 |   0.0 |  0.00
Modify  | 0.19532    | 0.19532    | 0.19532    |   0.0 |  0.13
Other   |            | 0.03062    |            |       |  0.02

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

Total # of neighbors = 238994
Ave neighs/atom = 119.49700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.152847831396, Press = 0.586009556535082
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -8420.6945   -8420.6945   -8489.6708   -8489.6708    266.94531    266.94531    23736.602    23736.602    2406.5007    2406.5007 
   98000   -8417.7883   -8417.7883   -8488.3694   -8488.3694    273.15618    273.15618    23749.656    23749.656    1700.8325    1700.8325 
Loop time of 173.672 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.37     | 173.37     | 173.37     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048657   | 0.048657   | 0.048657   |   0.0 |  0.03
Output  | 0.00022136 | 0.00022136 | 0.00022136 |   0.0 |  0.00
Modify  | 0.2208     | 0.2208     | 0.2208     |   0.0 |  0.13
Other   |            | 0.03449    |            |       |  0.02

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

Total # of neighbors = 240078
Ave neighs/atom = 120.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.131650648624, Press = 1.68421086485114
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -8417.7883   -8417.7883   -8488.3694   -8488.3694    273.15618    273.15618    23749.656    23749.656    1700.8325    1700.8325 
   99000   -8420.1246   -8420.1246   -8489.1463   -8489.1463    267.12106    267.12106    23798.016    23798.016   -1868.6456   -1868.6456 
Loop time of 142.301 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.05     | 142.05     | 142.05     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038991   | 0.038991   | 0.038991   |   0.0 |  0.03
Output  | 9.8241e-05 | 9.8241e-05 | 9.8241e-05 |   0.0 |  0.00
Modify  | 0.18105    | 0.18105    | 0.18105    |   0.0 |  0.13
Other   |            | 0.02868    |            |       |  0.02

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

Total # of neighbors = 239782
Ave neighs/atom = 119.89100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.115067164068, Press = 1.08746767045081
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -8420.1246   -8420.1246   -8489.1463   -8489.1463    267.12106    267.12106    23798.016    23798.016   -1868.6456   -1868.6456 
  100000    -8421.087    -8421.087   -8490.2794   -8490.2794    267.78176    267.78176    23774.616    23774.616   -359.90482   -359.90482 
Loop time of 172.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.887 hours/ns, 5.801 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    | 172.09     | 172.09     | 172.09     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047149   | 0.047149   | 0.047149   |   0.0 |  0.03
Output  | 0.00015198 | 0.00015198 | 0.00015198 |   0.0 |  0.00
Modify  | 0.21926    | 0.21926    | 0.21926    |   0.0 |  0.13
Other   |            | 0.03508    |            |       |  0.02

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

Total # of neighbors = 238970
Ave neighs/atom = 119.48500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.120845222485, Press = 0.672980851575169
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000    -8421.087    -8421.087   -8490.2794   -8490.2794    267.78176    267.78176    23774.616    23774.616   -359.90482   -359.90482 
  101000   -8419.8144   -8419.8144   -8490.6417   -8490.6417      274.109      274.109    23765.693    23765.693    341.99097    341.99097 
Loop time of 214.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.403 ns/day, 59.590 hours/ns, 4.662 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    | 214.15     | 214.15     | 214.15     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062622   | 0.062622   | 0.062622   |   0.0 |  0.03
Output  | 0.00024752 | 0.00024752 | 0.00024752 |   0.0 |  0.00
Modify  | 0.27075    | 0.27075    | 0.27075    |   0.0 |  0.13
Other   |            | 0.04304    |            |       |  0.02

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

Total # of neighbors = 239156
Ave neighs/atom = 119.57800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.111547575372, Press = 0.781305575326197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -8419.8144   -8419.8144   -8490.6417   -8490.6417      274.109      274.109    23765.693    23765.693    341.99097    341.99097 
  102000   -8417.9069   -8417.9069   -8488.6804   -8488.6804    273.90082    273.90082    23764.128    23764.128    690.54223    690.54223 
Loop time of 223.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.387 ns/day, 62.063 hours/ns, 4.476 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    | 223.04     | 223.04     | 223.04     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063557   | 0.063557   | 0.063557   |   0.0 |  0.03
Output  | 9.9856e-05 | 9.9856e-05 | 9.9856e-05 |   0.0 |  0.00
Modify  | 0.27819    | 0.27819    | 0.27819    |   0.0 |  0.12
Other   |            | 0.04381    |            |       |  0.02

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

Total # of neighbors = 239242
Ave neighs/atom = 119.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.101030598008, Press = 0.986835568015189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -8417.9069   -8417.9069   -8488.6804   -8488.6804    273.90082    273.90082    23764.128    23764.128    690.54223    690.54223 
  103000   -8420.7773   -8420.7773   -8490.9131   -8490.9131    271.43276    271.43276    23789.135    23789.135   -1443.2575   -1443.2575 
Loop time of 217.552 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.397 ns/day, 60.431 hours/ns, 4.597 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.18     | 217.18     | 217.18     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.03
Output  | 0.00014623 | 0.00014623 | 0.00014623 |   0.0 |  0.00
Modify  | 0.2689     | 0.2689     | 0.2689     |   0.0 |  0.12
Other   |            | 0.04258    |            |       |  0.02

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

Total # of neighbors = 239500
Ave neighs/atom = 119.75000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.088898644491, Press = 1.18408100772381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -8420.7773   -8420.7773   -8490.9131   -8490.9131    271.43276    271.43276    23789.135    23789.135   -1443.2575   -1443.2575 
  104000   -8416.3669   -8416.3669   -8486.8164   -8486.8164    272.64675    272.64675    23802.065    23802.065   -1647.5278   -1647.5278 
Loop time of 198.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.081 hours/ns, 5.043 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.94     | 197.94     | 197.94     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056467   | 0.056467   | 0.056467   |   0.0 |  0.03
Output  | 7.831e-05  | 7.831e-05  | 7.831e-05  |   0.0 |  0.00
Modify  | 0.25035    | 0.25035    | 0.25035    |   0.0 |  0.13
Other   |            | 0.04116    |            |       |  0.02

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0