# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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   -8494.5875   -8494.5875   -8559.9992   -8559.9992       253.15       253.15    23579.911    23579.911      2963.01      2963.01 
    1000    -8430.604    -8430.604   -8495.6305   -8495.6305    251.65951    251.65951    23791.563    23791.563   -2529.3618   -2529.3618 
Loop time of 237.675 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.364 ns/day, 66.021 hours/ns, 4.207 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    | 237.27     | 237.27     | 237.27     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.066065   | 0.066065   | 0.066065   |   0.0 |  0.03
Output  | 0.0004307  | 0.0004307  | 0.0004307  |   0.0 |  0.00
Modify  | 0.29363    | 0.29363    | 0.29363    |   0.0 |  0.12
Other   |            | 0.0476     |            |       |  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    -8430.604    -8430.604   -8495.6305   -8495.6305    251.65951    251.65951    23791.563    23791.563   -2529.3618   -2529.3618 
    2000   -8428.1247   -8428.1247   -8492.8544   -8492.8544    250.51088    250.51088    23746.265    23746.265    821.21986    821.21986 
Loop time of 215.345 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.401 ns/day, 59.818 hours/ns, 4.644 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    | 214.98     | 214.98     | 214.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058995   | 0.058995   | 0.058995   |   0.0 |  0.03
Output  | 0.00013256 | 0.00013256 | 0.00013256 |   0.0 |  0.00
Modify  | 0.26116    | 0.26116    | 0.26116    |   0.0 |  0.12
Other   |            | 0.0426     |            |       |  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:      238820.0 ave      238820 max      238820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238820
Ave neighs/atom = 119.41000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8428.1247   -8428.1247   -8492.8544   -8492.8544    250.51088    250.51088    23746.265    23746.265    821.21986    821.21986 
    3000   -8430.8402   -8430.8402   -8494.7512   -8494.7512    247.34218    247.34218    23758.304    23758.304    -129.3178    -129.3178 
Loop time of 198.888 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.434 ns/day, 55.247 hours/ns, 5.028 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    | 198.55     | 198.55     | 198.55     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054643   | 0.054643   | 0.054643   |   0.0 |  0.03
Output  | 0.00039454 | 0.00039454 | 0.00039454 |   0.0 |  0.00
Modify  | 0.24301    | 0.24301    | 0.24301    |   0.0 |  0.12
Other   |            | 0.04008    |            |       |  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:      239810.0 ave      239810 max      239810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239810
Ave neighs/atom = 119.90500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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   -8430.8402   -8430.8402   -8494.7512   -8494.7512    247.34218    247.34218    23758.304    23758.304    -129.3178    -129.3178 
    4000   -8428.0376   -8428.0376   -8492.1862   -8492.1862    248.26178    248.26178    23763.753    23763.753   -295.55638   -295.55638 
Loop time of 162.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.530 ns/day, 45.275 hours/ns, 6.135 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.71     | 162.71     | 162.71     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044398   | 0.044398   | 0.044398   |   0.0 |  0.03
Output  | 0.00014523 | 0.00014523 | 0.00014523 |   0.0 |  0.00
Modify  | 0.20078    | 0.20078    | 0.20078    |   0.0 |  0.12
Other   |            | 0.03332    |            |       |  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:      239310.0 ave      239310 max      239310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239310
Ave neighs/atom = 119.65500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8428.0376   -8428.0376   -8492.1862   -8492.1862    248.26178    248.26178    23763.753    23763.753   -295.55638   -295.55638 
    5000   -8431.1829   -8431.1829   -8495.7794   -8495.7794    249.99514    249.99514     23750.27     23750.27    253.93177    253.93177 
Loop time of 150.916 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.573 ns/day, 41.921 hours/ns, 6.626 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.66     | 150.66     | 150.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041206   | 0.041206   | 0.041206   |   0.0 |  0.03
Output  | 0.00021254 | 0.00021254 | 0.00021254 |   0.0 |  0.00
Modify  | 0.18608    | 0.18608    | 0.18608    |   0.0 |  0.12
Other   |            | 0.03055    |            |       |  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:      239558.0 ave      239558 max      239558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239558
Ave neighs/atom = 119.77900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 248.503731965135, Press = -1363.56615504523
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.1829   -8431.1829   -8495.7794   -8495.7794    249.99514    249.99514     23750.27     23750.27    253.93177    253.93177 
    6000   -8431.6658   -8431.6658   -8494.2599   -8494.2599    242.24563    242.24563    23746.479    23746.479    611.56145    611.56145 
Loop time of 166.113 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.142 hours/ns, 6.020 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    | 165.83     | 165.83     | 165.83     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0445     | 0.0445     | 0.0445     |   0.0 |  0.03
Output  | 0.00010618 | 0.00010618 | 0.00010618 |   0.0 |  0.00
Modify  | 0.2065     | 0.2065     | 0.2065     |   0.0 |  0.12
Other   |            | 0.03158    |            |       |  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:      239438.0 ave      239438 max      239438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239438
Ave neighs/atom = 119.71900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.859421140136, Press = -18.4895694839139
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.6658   -8431.6658   -8494.2599   -8494.2599    242.24563    242.24563    23746.479    23746.479    611.56145    611.56145 
    7000   -8427.0011   -8427.0011   -8493.5044   -8493.5044    257.37461    257.37461    23755.063    23755.063    313.43704    313.43704 
Loop time of 156.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.552 ns/day, 43.459 hours/ns, 6.392 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.18     | 156.18     | 156.18     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043024   | 0.043024   | 0.043024   |   0.0 |  0.03
Output  | 0.00021534 | 0.00021534 | 0.00021534 |   0.0 |  0.00
Modify  | 0.19701    | 0.19701    | 0.19701    |   0.0 |  0.13
Other   |            | 0.03061    |            |       |  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:      239702.0 ave      239702 max      239702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239702
Ave neighs/atom = 119.85100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.827532255756, Press = -39.456579137084
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.0011   -8427.0011   -8493.5044   -8493.5044    257.37461    257.37461    23755.063    23755.063    313.43704    313.43704 
    8000   -8428.5166   -8428.5166   -8494.9296   -8494.9296    257.02506    257.02506    23765.075    23765.075   -606.03937   -606.03937 
Loop time of 169.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.019 hours/ns, 5.908 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    | 168.97     | 168.97     | 168.97     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046299   | 0.046299   | 0.046299   |   0.0 |  0.03
Output  | 0.00025836 | 0.00025836 | 0.00025836 |   0.0 |  0.00
Modify  | 0.21446    | 0.21446    | 0.21446    |   0.0 |  0.13
Other   |            | 0.03334    |            |       |  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:      239492.0 ave      239492 max      239492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239492
Ave neighs/atom = 119.74600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.172574123801, Press = -10.1662837772886
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.5166   -8428.5166   -8494.9296   -8494.9296    257.02506    257.02506    23765.075    23765.075   -606.03937   -606.03937 
    9000   -8430.8598   -8430.8598   -8495.8272   -8495.8272    251.43034    251.43034    23735.961    23735.961    1265.5454    1265.5454 
Loop time of 198.238 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.066 hours/ns, 5.044 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    | 197.9      | 197.9      | 197.9      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053727   | 0.053727   | 0.053727   |   0.0 |  0.03
Output  | 0.00041289 | 0.00041289 | 0.00041289 |   0.0 |  0.00
Modify  | 0.24849    | 0.24849    | 0.24849    |   0.0 |  0.13
Other   |            | 0.03839    |            |       |  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:      239340.0 ave      239340 max      239340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239340
Ave neighs/atom = 119.67000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.136046178737, Press = -22.5211970154807
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.8598   -8430.8598   -8495.8272   -8495.8272    251.43034    251.43034    23735.961    23735.961    1265.5454    1265.5454 
   10000   -8428.1109   -8428.1109   -8494.7871   -8494.7871    258.04386    258.04386    23782.463    23782.463   -1693.3948   -1693.3948 
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.8      | 224.8      | 224.8      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.03
Output  | 0.00011975 | 0.00011975 | 0.00011975 |   0.0 |  0.00
Modify  | 0.28587    | 0.28587    | 0.28587    |   0.0 |  0.13
Other   |            | 0.04525    |            |       |  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:      239850.0 ave      239850 max      239850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239850
Ave neighs/atom = 119.92500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.368469344679, Press = -6.4788830045273
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.1109   -8428.1109   -8494.7871   -8494.7871    258.04386    258.04386    23782.463    23782.463   -1693.3948   -1693.3948 
   11000   -8428.9022   -8428.9022   -8494.3007   -8494.3007    253.09924    253.09924    23740.027    23740.027    1286.9104    1286.9104 
Loop time of 217.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.398 ns/day, 60.278 hours/ns, 4.608 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    | 216.63     | 216.63     | 216.63     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059003   | 0.059003   | 0.059003   |   0.0 |  0.03
Output  | 0.00017006 | 0.00017006 | 0.00017006 |   0.0 |  0.00
Modify  | 0.27454    | 0.27454    | 0.27454    |   0.0 |  0.13
Other   |            | 0.04316    |            |       |  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:      238910.0 ave      238910 max      238910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238910
Ave neighs/atom = 119.45500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.110473971897, Press = -13.1848314088825
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.9022   -8428.9022   -8494.3007   -8494.3007    253.09924    253.09924    23740.027    23740.027    1286.9104    1286.9104 
   12000   -8431.2981   -8431.2981   -8495.1106   -8495.1106     246.9607     246.9607    23781.551    23781.551   -1852.2993   -1852.2993 
Loop time of 229.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.756 hours/ns, 4.357 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.12     | 229.12     | 229.12     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.061382   | 0.061382   | 0.061382   |   0.0 |  0.03
Output  | 0.00023454 | 0.00023454 | 0.00023454 |   0.0 |  0.00
Modify  | 0.29026    | 0.29026    | 0.29026    |   0.0 |  0.13
Other   |            | 0.04674    |            |       |  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:      239738.0 ave      239738 max      239738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239738
Ave neighs/atom = 119.86900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.880488410258, Press = -5.46145693784517
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.2981   -8431.2981   -8495.1106   -8495.1106     246.9607     246.9607    23781.551    23781.551   -1852.2993   -1852.2993 
   13000   -8427.8888   -8427.8888   -8493.7907   -8493.7907     255.0473     255.0473    23718.777    23718.777    2851.7043    2851.7043 
Loop time of 198.099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.027 hours/ns, 5.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.75     | 197.75     | 197.75     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053964   | 0.053964   | 0.053964   |   0.0 |  0.03
Output  | 0.00019082 | 0.00019082 | 0.00019082 |   0.0 |  0.00
Modify  | 0.25325    | 0.25325    | 0.25325    |   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:        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:      238910.0 ave      238910 max      238910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238910
Ave neighs/atom = 119.45500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.728400572532, Press = -7.46734204450662
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.8888   -8427.8888   -8493.7907   -8493.7907     255.0473     255.0473    23718.777    23718.777    2851.7043    2851.7043 
   14000   -8432.3527   -8432.3527   -8495.8401   -8495.8401    245.70277    245.70277    23803.609    23803.609   -3479.0542   -3479.0542 
Loop time of 152.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.565 ns/day, 42.461 hours/ns, 6.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.59     | 152.59     | 152.59     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041096   | 0.041096   | 0.041096   |   0.0 |  0.03
Output  | 0.00011235 | 0.00011235 | 0.00011235 |   0.0 |  0.00
Modify  | 0.1946     | 0.1946     | 0.1946     |   0.0 |  0.13
Other   |            | 0.03058    |            |       |  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:      240168.0 ave      240168 max      240168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240168
Ave neighs/atom = 120.08400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.733815487694, Press = -4.76327480718516
next a
jump SELF top
variable a loop 2000
run 1000
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   -8432.3527   -8432.3527   -8495.8401   -8495.8401    245.70277    245.70277    23803.609    23803.609   -3479.0542   -3479.0542 
   15000   -8427.3163   -8427.3163   -8494.5493   -8494.5493    260.19836    260.19836    23734.183    23734.183    1731.2772    1731.2772 
Loop time of 154.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.560 ns/day, 42.869 hours/ns, 6.480 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.06     | 154.06     | 154.06     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042017   | 0.042017   | 0.042017   |   0.0 |  0.03
Output  | 0.00010801 | 0.00010801 | 0.00010801 |   0.0 |  0.00
Modify  | 0.19748    | 0.19748    | 0.19748    |   0.0 |  0.13
Other   |            | 0.03092    |            |       |  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:      238608.0 ave      238608 max      238608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238608
Ave neighs/atom = 119.30400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.78854449533, Press = -5.19706776566987
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.3163   -8427.3163   -8494.5493   -8494.5493    260.19836    260.19836    23734.183    23734.183    1731.2772    1731.2772 
   16000   -8430.9806   -8430.9806   -8496.3683   -8496.3683     253.0572     253.0572    23767.032    23767.032   -948.53861   -948.53861 
Loop time of 180.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.254 hours/ns, 5.527 timesteps/s
97.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    | 180.61     | 180.61     | 180.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047057   | 0.047057   | 0.047057   |   0.0 |  0.03
Output  | 0.00010229 | 0.00010229 | 0.00010229 |   0.0 |  0.00
Modify  | 0.22062    | 0.22062    | 0.22062    |   0.0 |  0.12
Other   |            | 0.03451    |            |       |  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:      239678.0 ave      239678 max      239678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239678
Ave neighs/atom = 119.83900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.897027198352, Press = -4.43121979202665
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.9806   -8430.9806   -8496.3683   -8496.3683     253.0572     253.0572    23767.032    23767.032   -948.53861   -948.53861 
   17000   -8424.5812   -8424.5812   -8493.7375   -8493.7375    267.64207    267.64207    23757.848    23757.848    278.40804    278.40804 
Loop time of 146.407 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.669 hours/ns, 6.830 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.15     | 146.15     | 146.15     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039082   | 0.039082   | 0.039082   |   0.0 |  0.03
Output  | 0.0001906  | 0.0001906  | 0.0001906  |   0.0 |  0.00
Modify  | 0.18647    | 0.18647    | 0.18647    |   0.0 |  0.13
Other   |            | 0.02958    |            |       |  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:      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 = 253.032912507095, Press = -4.80027172689832
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.5812   -8424.5812   -8493.7375   -8493.7375    267.64207    267.64207    23757.848    23757.848    278.40804    278.40804 
   18000   -8429.3619   -8429.3619   -8495.6498   -8495.6498    256.54083    256.54083    23782.427    23782.427    -1807.422    -1807.422 
Loop time of 155.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.179 hours/ns, 6.433 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.17     | 155.17     | 155.17     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041961   | 0.041961   | 0.041961   |   0.0 |  0.03
Output  | 0.00010305 | 0.00010305 | 0.00010305 |   0.0 |  0.00
Modify  | 0.19866    | 0.19866    | 0.19866    |   0.0 |  0.13
Other   |            | 0.03136    |            |       |  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:      239580.0 ave      239580 max      239580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239580
Ave neighs/atom = 119.79000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.07522297082, Press = -3.48137303306467
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.3619   -8429.3619   -8495.6498   -8495.6498    256.54083    256.54083    23782.427    23782.427    -1807.422    -1807.422 
   19000   -8433.1497   -8433.1497   -8496.3011   -8496.3011    244.40228    244.40228    23703.436    23703.436    3452.8387    3452.8387 
Loop time of 162.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.531 ns/day, 45.222 hours/ns, 6.142 timesteps/s
98.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.52     | 162.52     | 162.52     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043287   | 0.043287   | 0.043287   |   0.0 |  0.03
Output  | 0.00011494 | 0.00011494 | 0.00011494 |   0.0 |  0.00
Modify  | 0.20506    | 0.20506    | 0.20506    |   0.0 |  0.13
Other   |            | 0.03194    |            |       |  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:      238910.0 ave      238910 max      238910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238910
Ave neighs/atom = 119.45500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.029119893789, Press = -4.96262801926775
next a
jump SELF top
variable a loop 2000
run 1000
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   -8433.1497   -8433.1497   -8496.3011   -8496.3011    244.40228    244.40228    23703.436    23703.436    3452.8387    3452.8387 
   20000   -8430.4261   -8430.4261   -8495.4861   -8495.4861    251.78864    251.78864    23799.641    23799.641   -3050.1455   -3050.1455 
Loop time of 152.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.567 ns/day, 42.320 hours/ns, 6.564 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.09     | 152.09     | 152.09     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040793   | 0.040793   | 0.040793   |   0.0 |  0.03
Output  | 0.00018991 | 0.00018991 | 0.00018991 |   0.0 |  0.00
Modify  | 0.19376    | 0.19376    | 0.19376    |   0.0 |  0.13
Other   |            | 0.03084    |            |       |  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:      240248.0 ave      240248 max      240248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240248
Ave neighs/atom = 120.12400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.821997501159, Press = -3.47220322804461
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.4261   -8430.4261   -8495.4861   -8495.4861    251.78864    251.78864    23799.641    23799.641   -3050.1455   -3050.1455 
   21000   -8427.0031   -8427.0031   -8495.0603   -8495.0603    263.38858    263.38858    23737.022    23737.022    1492.2236    1492.2236 
Loop time of 162.324 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.532 ns/day, 45.090 hours/ns, 6.161 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.04     | 162.04     | 162.04     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043892   | 0.043892   | 0.043892   |   0.0 |  0.03
Output  | 0.00017198 | 0.00017198 | 0.00017198 |   0.0 |  0.00
Modify  | 0.20774    | 0.20774    | 0.20774    |   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:        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:      238614.0 ave      238614 max      238614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238614
Ave neighs/atom = 119.30700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.779684259744, Press = -2.95057000375859
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.0031   -8427.0031   -8495.0603   -8495.0603    263.38858    263.38858    23737.022    23737.022    1492.2236    1492.2236 
   22000   -8431.0336   -8431.0336   -8497.2527   -8497.2527    256.27453    256.27453    23776.037    23776.037   -1552.2581   -1552.2581 
Loop time of 164.225 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.526 ns/day, 45.618 hours/ns, 6.089 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 163.94     | 163.94     | 163.94     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044054   | 0.044054   | 0.044054   |   0.0 |  0.03
Output  | 0.00011137 | 0.00011137 | 0.00011137 |   0.0 |  0.00
Modify  | 0.2083     | 0.2083     | 0.2083     |   0.0 |  0.13
Other   |            | 0.03304    |            |       |  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:      239764.0 ave      239764 max      239764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239764
Ave neighs/atom = 119.88200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.900269532945, Press = -4.05689967461363
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.0336   -8431.0336   -8497.2527   -8497.2527    256.27453    256.27453    23776.037    23776.037   -1552.2581   -1552.2581 
   23000    -8428.885    -8428.885   -8493.5601   -8493.5601    250.29941    250.29941     23741.46     23741.46    1158.4485    1158.4485 
Loop time of 154.845 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.558 ns/day, 43.013 hours/ns, 6.458 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 154.57     | 154.57     | 154.57     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041883   | 0.041883   | 0.041883   |   0.0 |  0.03
Output  | 0.00018733 | 0.00018733 | 0.00018733 |   0.0 |  0.00
Modify  | 0.19773    | 0.19773    | 0.19773    |   0.0 |  0.13
Other   |            | 0.03195    |            |       |  0.02

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

Total # of neighbors = 238720
Ave neighs/atom = 119.36000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.930413407224, Press = -1.80517599580089
next a
jump SELF top
variable a loop 2000
run 1000
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    -8428.885    -8428.885   -8493.5601   -8493.5601    250.29941    250.29941     23741.46     23741.46    1158.4485    1158.4485 
   24000   -8427.2517   -8427.2517   -8492.3605   -8492.3605    251.97782    251.97782    23785.565    23785.565   -1648.7095   -1648.7095 
Loop time of 163.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.530 ns/day, 45.285 hours/ns, 6.134 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    | 162.74     | 162.74     | 162.74     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044141   | 0.044141   | 0.044141   |   0.0 |  0.03
Output  | 0.00011159 | 0.00011159 | 0.00011159 |   0.0 |  0.00
Modify  | 0.20754    | 0.20754    | 0.20754    |   0.0 |  0.13
Other   |            | 0.03291    |            |       |  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:      239776.0 ave      239776 max      239776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239776
Ave neighs/atom = 119.88800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.84754528646, Press = -4.6543209436413
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.2517   -8427.2517   -8492.3605   -8492.3605    251.97782    251.97782    23785.565    23785.565   -1648.7095   -1648.7095 
   25000   -8429.2825   -8429.2825   -8494.0171   -8494.0171    250.52987    250.52987    23720.217    23720.217    2653.8213    2653.8213 
Loop time of 180.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.075 hours/ns, 5.547 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.95     | 179.95     | 179.95     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04904    | 0.04904    | 0.04904    |   0.0 |  0.03
Output  | 0.00010246 | 0.00010246 | 0.00010246 |   0.0 |  0.00
Modify  | 0.23088    | 0.23088    | 0.23088    |   0.0 |  0.13
Other   |            | 0.03673    |            |       |  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:      239036.0 ave      239036 max      239036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239036
Ave neighs/atom = 119.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.911569681802, Press = -0.116006261043437
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.2825   -8429.2825   -8494.0171   -8494.0171    250.52987    250.52987    23720.217    23720.217    2653.8213    2653.8213 
   26000   -8427.4406   -8427.4406   -8492.8418   -8492.8418    253.10934    253.10934    23792.813    23792.813   -2178.6685   -2178.6685 
Loop time of 165.297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.523 ns/day, 45.916 hours/ns, 6.050 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 165        | 165        | 165        |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044876   | 0.044876   | 0.044876   |   0.0 |  0.03
Output  | 0.00010463 | 0.00010463 | 0.00010463 |   0.0 |  0.00
Modify  | 0.21278    | 0.21278    | 0.21278    |   0.0 |  0.13
Other   |            | 0.03565    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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 = 252.987673959218, Press = -4.8073939027655
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.4406   -8427.4406   -8492.8418   -8492.8418    253.10934    253.10934    23792.813    23792.813   -2178.6685   -2178.6685 
   27000   -8429.3585   -8429.3585   -8494.2082   -8494.2082    250.97501    250.97501    23740.289    23740.289    1285.8936    1285.8936 
Loop time of 222.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.388 ns/day, 61.895 hours/ns, 4.488 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.43     | 222.43     | 222.43     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059278   | 0.059278   | 0.059278   |   0.0 |  0.03
Output  | 0.00017423 | 0.00017423 | 0.00017423 |   0.0 |  0.00
Modify  | 0.28116    | 0.28116    | 0.28116    |   0.0 |  0.13
Other   |            | 0.04645    |            |       |  0.02

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

Total # of neighbors = 239082
Ave neighs/atom = 119.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.965208752544, Press = -0.821498231950681
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.3585   -8429.3585   -8494.2082   -8494.2082    250.97501    250.97501    23740.289    23740.289    1285.8936    1285.8936 
   28000   -8432.5753   -8432.5753   -8495.7665   -8495.7665    244.55636    244.55636    23752.392    23752.392    115.73666    115.73666 
Loop time of 259.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.333 ns/day, 72.057 hours/ns, 3.855 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 258.97     | 258.97     | 258.97     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.068562   | 0.068562   | 0.068562   |   0.0 |  0.03
Output  | 0.00016497 | 0.00016497 | 0.00016497 |   0.0 |  0.00
Modify  | 0.32025    | 0.32025    | 0.32025    |   0.0 |  0.12
Other   |            | 0.04814    |            |       |  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:      239716.0 ave      239716 max      239716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239716
Ave neighs/atom = 119.85800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.942009922439, Press = -3.40911764640469
next a
jump SELF top
variable a loop 2000
run 1000
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   -8432.5753   -8432.5753   -8495.7665   -8495.7665    244.55636    244.55636    23752.392    23752.392    115.73666    115.73666 
   29000   -8428.9425   -8428.9425   -8496.0088   -8496.0088    259.55343    259.55343    23758.566    23758.566   -196.58291   -196.58291 
Loop time of 199.671 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.433 ns/day, 55.464 hours/ns, 5.008 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    | 199.32     | 199.32     | 199.32     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054224   | 0.054224   | 0.054224   |   0.0 |  0.03
Output  | 0.00010735 | 0.00010735 | 0.00010735 |   0.0 |  0.00
Modify  | 0.25162    | 0.25162    | 0.25162    |   0.0 |  0.13
Other   |            | 0.04034    |            |       |  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:      239358.0 ave      239358 max      239358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239358
Ave neighs/atom = 119.67900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.879683783733, Press = -1.56493923317416
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.9425   -8428.9425   -8496.0088   -8496.0088    259.55343    259.55343    23758.566    23758.566   -196.58291   -196.58291 
   30000   -8429.2855   -8429.2855    -8493.967    -8493.967    250.32415    250.32415     23752.65     23752.65    454.65553    454.65553 
Loop time of 206.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.418 ns/day, 57.408 hours/ns, 4.839 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    | 206.31     | 206.31     | 206.31     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054996   | 0.054996   | 0.054996   |   0.0 |  0.03
Output  | 0.00019321 | 0.00019321 | 0.00019321 |   0.0 |  0.00
Modify  | 0.25957    | 0.25957    | 0.25957    |   0.0 |  0.13
Other   |            | 0.04135    |            |       |  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:      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 = 252.87191949977, Press = -3.06886623476302
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.2855   -8429.2855    -8493.967    -8493.967    250.32415    250.32415     23752.65     23752.65    454.65553    454.65553 
   31000   -8427.4578   -8427.4578   -8495.2545   -8495.2545    262.38053    262.38053    23765.075    23765.075    -523.3449    -523.3449 
Loop time of 266.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.324 ns/day, 74.061 hours/ns, 3.751 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    | 266.17     | 266.17     | 266.17     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.069671   | 0.069671   | 0.069671   |   0.0 |  0.03
Output  | 0.00028422 | 0.00028422 | 0.00028422 |   0.0 |  0.00
Modify  | 0.32637    | 0.32637    | 0.32637    |   0.0 |  0.12
Other   |            | 0.04938    |            |       |  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:      239520.0 ave      239520 max      239520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239520
Ave neighs/atom = 119.76000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.877085307538, Press = -1.34606854318026
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.4578   -8427.4578   -8495.2545   -8495.2545    262.38053    262.38053    23765.075    23765.075    -523.3449    -523.3449 
   32000   -8432.2227   -8432.2227   -8495.6631   -8495.6631    245.52098    245.52098    23749.954    23749.954    314.92625    314.92625 
Loop time of 234.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.160 hours/ns, 4.263 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    | 234.17     | 234.17     | 234.17     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062915   | 0.062915   | 0.062915   |   0.0 |  0.03
Output  | 0.00010869 | 0.00010869 | 0.00010869 |   0.0 |  0.00
Modify  | 0.29421    | 0.29421    | 0.29421    |   0.0 |  0.13
Other   |            | 0.04669    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      239092.0 ave      239092 max      239092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239092
Ave neighs/atom = 119.54600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.803403839684, Press = -2.72855516518613
next a
jump SELF top
variable a loop 2000
run 1000
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   -8432.2227   -8432.2227   -8495.6631   -8495.6631    245.52098    245.52098    23749.954    23749.954    314.92625    314.92625 
   33000   -8429.3669   -8429.3669   -8495.0094   -8495.0094    254.04335    254.04335    23763.702    23763.702   -449.21647   -449.21647 
Loop time of 271.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.318 ns/day, 75.545 hours/ns, 3.677 timesteps/s
93.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    | 271.5      | 271.5      | 271.5      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08023    | 0.08023    | 0.08023    |   0.0 |  0.03
Output  | 0.00016649 | 0.00016649 | 0.00016649 |   0.0 |  0.00
Modify  | 0.33836    | 0.33836    | 0.33836    |   0.0 |  0.12
Other   |            | 0.04877    |            |       |  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:      239418.0 ave      239418 max      239418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239418
Ave neighs/atom = 119.70900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.796842596739, Press = -1.11902115118895
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.3669   -8429.3669   -8495.0094   -8495.0094    254.04335    254.04335    23763.702    23763.702   -449.21647   -449.21647 
   34000   -8432.1947   -8432.1947   -8496.6809   -8496.6809    249.56827    249.56827    23736.455    23736.455     1166.459     1166.459 
Loop time of 224.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.454 hours/ns, 4.448 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    | 224.45     | 224.45     | 224.45     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058635   | 0.058635   | 0.058635   |   0.0 |  0.03
Output  | 0.00012463 | 0.00012463 | 0.00012463 |   0.0 |  0.00
Modify  | 0.27778    | 0.27778    | 0.27778    |   0.0 |  0.12
Other   |            | 0.04275    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      239206.0 ave      239206 max      239206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239206
Ave neighs/atom = 119.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.724352416894, Press = -3.96662207241606
next a
jump SELF top
variable a loop 2000
run 1000
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   -8432.1947   -8432.1947   -8496.6809   -8496.6809    249.56827    249.56827    23736.455    23736.455     1166.459     1166.459 
   35000    -8430.576    -8430.576   -8494.1932   -8494.1932    246.20525    246.20525    23780.125    23780.125   -1501.3061   -1501.3061 
Loop time of 203.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.508 hours/ns, 4.916 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    | 203.07     | 203.07     | 203.07     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055099   | 0.055099   | 0.055099   |   0.0 |  0.03
Output  | 0.00019891 | 0.00019891 | 0.00019891 |   0.0 |  0.00
Modify  | 0.25804    | 0.25804    | 0.25804    |   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:        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:      239724.0 ave      239724 max      239724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239724
Ave neighs/atom = 119.86200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.746986442412, Press = 0.0814041018720846
next a
jump SELF top
variable a loop 2000
run 1000
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    -8430.576    -8430.576   -8494.1932   -8494.1932    246.20525    246.20525    23780.125    23780.125   -1501.3061   -1501.3061 
   36000   -8427.6436   -8427.6436    -8494.243    -8494.243    257.74661    257.74661    23738.876    23738.876    1418.8867    1418.8867 
Loop time of 187.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.460 ns/day, 52.152 hours/ns, 5.326 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.42     | 187.42     | 187.42     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051913   | 0.051913   | 0.051913   |   0.0 |  0.03
Output  | 0.00011366 | 0.00011366 | 0.00011366 |   0.0 |  0.00
Modify  | 0.24176    | 0.24176    | 0.24176    |   0.0 |  0.13
Other   |            | 0.03906    |            |       |  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:      238916.0 ave      238916 max      238916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238916
Ave neighs/atom = 119.45800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.739734591977, Press = -2.85104481628728
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.6436   -8427.6436    -8494.243    -8494.243    257.74661    257.74661    23738.876    23738.876    1418.8867    1418.8867 
   37000    -8429.771    -8429.771   -8494.6736   -8494.6736    251.17973    251.17973    23769.198    23769.198   -894.80005   -894.80005 
Loop time of 215.931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.400 ns/day, 59.981 hours/ns, 4.631 timesteps/s
98.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    | 215.56     | 215.56     | 215.56     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056971   | 0.056971   | 0.056971   |   0.0 |  0.03
Output  | 0.00011434 | 0.00011434 | 0.00011434 |   0.0 |  0.00
Modify  | 0.26965    | 0.26965    | 0.26965    |   0.0 |  0.12
Other   |            | 0.04186    |            |       |  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:      239600.0 ave      239600 max      239600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239600
Ave neighs/atom = 119.80000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.722506949868, Press = -1.39025933737882
next a
jump SELF top
variable a loop 2000
run 1000
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    -8429.771    -8429.771   -8494.6736   -8494.6736    251.17973    251.17973    23769.198    23769.198   -894.80005   -894.80005 
   38000   -8428.2558   -8428.2558   -8494.4658   -8494.4658    256.23938    256.23938     23755.77     23755.77    178.64005    178.64005 
Loop time of 241.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.358 ns/day, 67.054 hours/ns, 4.143 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    | 240.98     | 240.98     | 240.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.064152   | 0.064152   | 0.064152   |   0.0 |  0.03
Output  | 0.00027543 | 0.00027543 | 0.00027543 |   0.0 |  0.00
Modify  | 0.30056    | 0.30056    | 0.30056    |   0.0 |  0.12
Other   |            | 0.04614    |            |       |  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:      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 = 252.70720312002, Press = -2.09936802739147
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.2558   -8428.2558   -8494.4658   -8494.4658    256.23938    256.23938     23755.77     23755.77    178.64005    178.64005 
   39000   -8429.2189   -8429.2189   -8494.6884   -8494.6884    253.37368    253.37368    23761.546    23761.546   -299.78933   -299.78933 
Loop time of 214.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.404 ns/day, 59.456 hours/ns, 4.672 timesteps/s
98.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    | 213.67     | 213.67     | 213.67     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.056641   | 0.056641   | 0.056641   |   0.0 |  0.03
Output  | 0.00018877 | 0.00018877 | 0.00018877 |   0.0 |  0.00
Modify  | 0.27062    | 0.27062    | 0.27062    |   0.0 |  0.13
Other   |            | 0.04446    |            |       |  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:      239456.0 ave      239456 max      239456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239456
Ave neighs/atom = 119.72800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.710842481801, Press = -1.68419734029289
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.2189   -8429.2189   -8494.6884   -8494.6884    253.37368    253.37368    23761.546    23761.546   -299.78933   -299.78933 
   40000   -8430.0325   -8430.0325   -8494.7642   -8494.7642    250.51842    250.51842    23752.685    23752.685       243.37       243.37 
Loop time of 159.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.540 ns/day, 44.442 hours/ns, 6.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 159.71     | 159.71     | 159.71     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043084   | 0.043084   | 0.043084   |   0.0 |  0.03
Output  | 0.00013176 | 0.00013176 | 0.00013176 |   0.0 |  0.00
Modify  | 0.20509    | 0.20509    | 0.20509    |   0.0 |  0.13
Other   |            | 0.03246    |            |       |  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:      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 = 252.783971134959, Press = -2.03551088244081
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.0325   -8430.0325   -8494.7642   -8494.7642    250.51842    250.51842    23752.685    23752.685       243.37       243.37 
   41000   -8427.7223   -8427.7223    -8495.146    -8495.146     260.9368     260.9368    23766.749    23766.749   -658.33699   -658.33699 
Loop time of 177.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.488 ns/day, 49.175 hours/ns, 5.649 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    | 176.72     | 176.72     | 176.72     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048031   | 0.048031   | 0.048031   |   0.0 |  0.03
Output  | 0.00014676 | 0.00014676 | 0.00014676 |   0.0 |  0.00
Modify  | 0.22705    | 0.22705    | 0.22705    |   0.0 |  0.13
Other   |            | 0.03661    |            |       |  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:      239452.0 ave      239452 max      239452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239452
Ave neighs/atom = 119.72600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.832607924985, Press = -1.37446034109042
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.7223   -8427.7223    -8495.146    -8495.146     260.9368     260.9368    23766.749    23766.749   -658.33699   -658.33699 
   42000   -8428.2562   -8428.2562   -8494.0162   -8494.0162    254.49777    254.49777    23747.142    23747.142    884.37913    884.37913 
Loop time of 148.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.169 hours/ns, 6.747 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    | 147.95     | 147.95     | 147.95     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03958    | 0.03958    | 0.03958    |   0.0 |  0.03
Output  | 9.7075e-05 | 9.7075e-05 | 9.7075e-05 |   0.0 |  0.00
Modify  | 0.18659    | 0.18659    | 0.18659    |   0.0 |  0.13
Other   |            | 0.02964    |            |       |  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:      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 = 252.832943585087, Press = -2.61709040596608
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.2562   -8428.2562   -8494.0162   -8494.0162    254.49777    254.49777    23747.142    23747.142    884.37913    884.37913 
   43000    -8429.496    -8429.496   -8494.8867   -8494.8867    253.06858    253.06858    23776.089    23776.089   -1291.8276   -1291.8276 
Loop time of 145.742 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.038284   | 0.038284   | 0.038284   |   0.0 |  0.03
Output  | 0.00017878 | 0.00017878 | 0.00017878 |   0.0 |  0.00
Modify  | 0.18293    | 0.18293    | 0.18293    |   0.0 |  0.13
Other   |            | 0.02843    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      239540.0 ave      239540 max      239540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239540
Ave neighs/atom = 119.77000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.904371047883, Press = -0.80127502586552
next a
jump SELF top
variable a loop 2000
run 1000
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    -8429.496    -8429.496   -8494.8867   -8494.8867    253.06858    253.06858    23776.089    23776.089   -1291.8276   -1291.8276 
   44000   -8427.3956   -8427.3956   -8492.5763   -8492.5763    252.25617    252.25617    23731.249    23731.249    2075.3621    2075.3621 
Loop time of 146.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.591 ns/day, 40.576 hours/ns, 6.846 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    | 145.82     | 145.82     | 145.82     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038361   | 0.038361   | 0.038361   |   0.0 |  0.03
Output  | 9.7538e-05 | 9.7538e-05 | 9.7538e-05 |   0.0 |  0.00
Modify  | 0.18282    | 0.18282    | 0.18282    |   0.0 |  0.13
Other   |            | 0.02869    |            |       |  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:      238826.0 ave      238826 max      238826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238826
Ave neighs/atom = 119.41300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.928303257642, Press = -2.6066784087779
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.3956   -8427.3956   -8492.5763   -8492.5763    252.25617    252.25617    23731.249    23731.249    2075.3621    2075.3621 
   45000   -8430.3205   -8430.3205   -8496.1804   -8496.1804    254.88447    254.88447    23789.965    23789.965   -2447.8346   -2447.8346 
Loop time of 146.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.589 ns/day, 40.739 hours/ns, 6.818 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.41     | 146.41     | 146.41     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038457   | 0.038457   | 0.038457   |   0.0 |  0.03
Output  | 9.4834e-05 | 9.4834e-05 | 9.4834e-05 |   0.0 |  0.00
Modify  | 0.18445    | 0.18445    | 0.18445    |   0.0 |  0.13
Other   |            | 0.02881    |            |       |  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:      239976.0 ave      239976 max      239976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239976
Ave neighs/atom = 119.98800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.952846243675, Press = -1.03885995491897
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.3205   -8430.3205   -8496.1804   -8496.1804    254.88447    254.88447    23789.965    23789.965   -2447.8346   -2447.8346 
   46000   -8428.3513   -8428.3513    -8495.291    -8495.291    259.06362    259.06362    23719.362    23719.362    2638.7637    2638.7637 
Loop time of 150.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.776 hours/ns, 6.649 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    | 150.14     | 150.14     | 150.14     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039703   | 0.039703   | 0.039703   |   0.0 |  0.03
Output  | 9.7385e-05 | 9.7385e-05 | 9.7385e-05 |   0.0 |  0.00
Modify  | 0.18839    | 0.18839    | 0.18839    |   0.0 |  0.13
Other   |            | 0.02946    |            |       |  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:      238664.0 ave      238664 max      238664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238664
Ave neighs/atom = 119.33200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937324410757, Press = -2.10043928554679
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.3513   -8428.3513    -8495.291    -8495.291    259.06362    259.06362    23719.362    23719.362    2638.7637    2638.7637 
   47000   -8430.5844   -8430.5844    -8495.507    -8495.507    251.25732    251.25732    23780.654    23780.654    -1725.267    -1725.267 
Loop time of 142.884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.605 ns/day, 39.690 hours/ns, 6.999 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.64     | 142.64     | 142.64     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0378     | 0.0378     | 0.0378     |   0.0 |  0.03
Output  | 9.6463e-05 | 9.6463e-05 | 9.6463e-05 |   0.0 |  0.00
Modify  | 0.17784    | 0.17784    | 0.17784    |   0.0 |  0.12
Other   |            | 0.02803    |            |       |  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:      239864.0 ave      239864 max      239864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239864
Ave neighs/atom = 119.93200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.951155257176, Press = -1.24055059741258
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.5844   -8430.5844    -8495.507    -8495.507    251.25732    251.25732    23780.654    23780.654    -1725.267    -1725.267 
   48000   -8427.0505   -8427.0505   -8493.8336   -8493.8336    258.45755    258.45755     23741.91     23741.91    1331.0277    1331.0277 
Loop time of 142.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.604 ns/day, 39.709 hours/ns, 6.995 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    | 142.71     | 142.71     | 142.71     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038006   | 0.038006   | 0.038006   |   0.0 |  0.03
Output  | 0.00010234 | 0.00010234 | 0.00010234 |   0.0 |  0.00
Modify  | 0.17752    | 0.17752    | 0.17752    |   0.0 |  0.12
Other   |            | 0.02818    |            |       |  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:      238802.0 ave      238802 max      238802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238802
Ave neighs/atom = 119.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.964086072499, Press = -1.69112620433999
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.0505   -8427.0505   -8493.8336   -8493.8336    258.45755    258.45755     23741.91     23741.91    1331.0277    1331.0277 
   49000   -8431.3144   -8431.3144   -8497.3575   -8497.3575    255.59358    255.59358     23769.28     23769.28   -1191.2233   -1191.2233 
Loop time of 158.616 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.545 ns/day, 44.060 hours/ns, 6.305 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    | 158.34     | 158.34     | 158.34     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042951   | 0.042951   | 0.042951   |   0.0 |  0.03
Output  | 0.0001036  | 0.0001036  | 0.0001036  |   0.0 |  0.00
Modify  | 0.2004     | 0.2004     | 0.2004     |   0.0 |  0.13
Other   |            | 0.03181    |            |       |  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:      239642.0 ave      239642 max      239642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239642
Ave neighs/atom = 119.82100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.947268989542, Press = -1.51835791204564
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.3144   -8431.3144   -8497.3575   -8497.3575    255.59358    255.59358     23769.28     23769.28   -1191.2233   -1191.2233 
   50000   -8427.6864   -8427.6864   -8494.5171   -8494.5171    258.64191    258.64191    23744.643    23744.643    984.25005    984.25005 
Loop time of 162.769 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.531 ns/day, 45.214 hours/ns, 6.144 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    | 162.49     | 162.49     | 162.49     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043288   | 0.043288   | 0.043288   |   0.0 |  0.03
Output  | 0.00010388 | 0.00010388 | 0.00010388 |   0.0 |  0.00
Modify  | 0.20394    | 0.20394    | 0.20394    |   0.0 |  0.13
Other   |            | 0.03193    |            |       |  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:      239066.0 ave      239066 max      239066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239066
Ave neighs/atom = 119.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.93815701919, Press = -1.26792145012261
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.6864   -8427.6864   -8494.5171   -8494.5171    258.64191    258.64191    23744.643    23744.643    984.25005    984.25005 
   51000   -8430.6046   -8430.6046   -8494.4969   -8494.4969    247.26974    247.26974    23786.322    23786.322   -1996.4712   -1996.4712 
Loop time of 158.968 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.544 ns/day, 44.158 hours/ns, 6.291 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    | 158.7      | 158.7      | 158.7      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042096   | 0.042096   | 0.042096   |   0.0 |  0.03
Output  | 9.9691e-05 | 9.9691e-05 | 9.9691e-05 |   0.0 |  0.00
Modify  | 0.19887    | 0.19887    | 0.19887    |   0.0 |  0.13
Other   |            | 0.03156    |            |       |  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:      239584.0 ave      239584 max      239584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239584
Ave neighs/atom = 119.79200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.91030138919, Press = -1.72650084451042
next a
jump SELF top
variable a loop 2000
run 1000
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   -8430.6046   -8430.6046   -8494.4969   -8494.4969    247.26974    247.26974    23786.322    23786.322   -1996.4712   -1996.4712 
   52000    -8427.922    -8427.922   -8495.8041   -8495.8041    262.71052    262.71052    23714.792    23714.792    3004.1416    3004.1416 
Loop time of 144.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.598 ns/day, 40.134 hours/ns, 6.921 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.23     | 144.23     | 144.23     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038704   | 0.038704   | 0.038704   |   0.0 |  0.03
Output  | 9.8149e-05 | 9.8149e-05 | 9.8149e-05 |   0.0 |  0.00
Modify  | 0.18031    | 0.18031    | 0.18031    |   0.0 |  0.12
Other   |            | 0.02859    |            |       |  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:      238730.0 ave      238730 max      238730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238730
Ave neighs/atom = 119.36500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937380916173, Press = -0.863786827114582
next a
jump SELF top
variable a loop 2000
run 1000
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    -8427.922    -8427.922   -8495.8041   -8495.8041    262.71052    262.71052    23714.792    23714.792    3004.1416    3004.1416 
   53000   -8426.0117   -8426.0117    -8493.917    -8493.917    262.80056    262.80056    23795.121    23795.121   -2351.7621   -2351.7621 
Loop time of 138.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.624 ns/day, 38.483 hours/ns, 7.218 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.3      | 138.3      | 138.3      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037009   | 0.037009   | 0.037009   |   0.0 |  0.03
Output  | 8.9295e-05 | 8.9295e-05 | 8.9295e-05 |   0.0 |  0.00
Modify  | 0.17151    | 0.17151    | 0.17151    |   0.0 |  0.12
Other   |            | 0.02742    |            |       |  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:      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 = 252.938569322672, Press = -1.81767271117874
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.0117   -8426.0117    -8493.917    -8493.917    262.80056    262.80056    23795.121    23795.121   -2351.7621   -2351.7621 
   54000   -8429.9449   -8429.9449   -8494.8426   -8494.8426    251.16062    251.16062    23737.551    23737.551     1386.819     1386.819 
Loop time of 136.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.012 hours/ns, 7.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.61     | 136.61     | 136.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036731   | 0.036731   | 0.036731   |   0.0 |  0.03
Output  | 9.184e-05  | 9.184e-05  | 9.184e-05  |   0.0 |  0.00
Modify  | 0.17092    | 0.17092    | 0.17092    |   0.0 |  0.12
Other   |            | 0.0281     |            |       |  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:      238844.0 ave      238844 max      238844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238844
Ave neighs/atom = 119.42200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.988730903427, Press = -0.875305769889434
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.9449   -8429.9449   -8494.8426   -8494.8426    251.16062    251.16062    23737.551    23737.551     1386.819     1386.819 
   55000   -8425.3796   -8425.3796   -8493.2688   -8493.2688    262.73827    262.73827    23770.373    23770.373    -573.4898    -573.4898 
Loop time of 136.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.635 ns/day, 37.819 hours/ns, 7.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    | 135.92     | 135.92     | 135.92     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036501   | 0.036501   | 0.036501   |   0.0 |  0.03
Output  | 9.5113e-05 | 9.5113e-05 | 9.5113e-05 |   0.0 |  0.00
Modify  | 0.17008    | 0.17008    | 0.17008    |   0.0 |  0.12
Other   |            | 0.02814    |            |       |  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:      239702.0 ave      239702 max      239702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239702
Ave neighs/atom = 119.85100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.019496443688, Press = -1.49451722175449
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.3796   -8425.3796   -8493.2688   -8493.2688    262.73827    262.73827    23770.373    23770.373    -573.4898    -573.4898 
   56000   -8429.8241   -8429.8241   -8492.9169   -8492.9169    244.17562    244.17562    23753.821    23753.821    439.82778    439.82778 
Loop time of 137.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.265 hours/ns, 7.259 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.52     | 137.52     | 137.52     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037038   | 0.037038   | 0.037038   |   0.0 |  0.03
Output  | 9.5575e-05 | 9.5575e-05 | 9.5575e-05 |   0.0 |  0.00
Modify  | 0.17139    | 0.17139    | 0.17139    |   0.0 |  0.12
Other   |            | 0.02824    |            |       |  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:      239272.0 ave      239272 max      239272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239272
Ave neighs/atom = 119.63600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.056061313703, Press = -0.997949429164052
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.8241   -8429.8241   -8492.9169   -8492.9169    244.17562    244.17562    23753.821    23753.821    439.82778    439.82778 
   57000   -8425.9684   -8425.9684   -8491.4476   -8491.4476    253.41129    253.41129    23767.289    23767.289   -167.56734   -167.56734 
Loop time of 140.934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.148 hours/ns, 7.095 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.69     | 140.69     | 140.69     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037981   | 0.037981   | 0.037981   |   0.0 |  0.03
Output  | 0.00033592 | 0.00033592 | 0.00033592 |   0.0 |  0.00
Modify  | 0.17539    | 0.17539    | 0.17539    |   0.0 |  0.12
Other   |            | 0.02774    |            |       |  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:      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 = 253.084753515714, Press = -1.71653256230744
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.9684   -8425.9684   -8491.4476   -8491.4476    253.41129    253.41129    23767.289    23767.289   -167.56734   -167.56734 
   58000   -8429.0467   -8429.0467   -8494.5875   -8494.5875    253.64948    253.64948    23759.269    23759.269    -72.79636    -72.79636 
Loop time of 176.016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.893 hours/ns, 5.681 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    | 175.72     | 175.72     | 175.72     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046877   | 0.046877   | 0.046877   |   0.0 |  0.03
Output  | 8.9816e-05 | 8.9816e-05 | 8.9816e-05 |   0.0 |  0.00
Modify  | 0.21863    | 0.21863    | 0.21863    |   0.0 |  0.12
Other   |            | 0.03409    |            |       |  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 = 253.082173645424, Press = -0.975239304860957
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.0467   -8429.0467   -8494.5875   -8494.5875    253.64948    253.64948    23759.269    23759.269    -72.79636    -72.79636 
   59000   -8431.7341   -8431.7341   -8496.4065   -8496.4065    250.28911    250.28911    23747.585    23747.585    404.96562    404.96562 
Loop time of 197.904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.973 hours/ns, 5.053 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    | 197.57     | 197.57     | 197.57     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052029   | 0.052029   | 0.052029   |   0.0 |  0.03
Output  | 0.00016846 | 0.00016846 | 0.00016846 |   0.0 |  0.00
Modify  | 0.24371    | 0.24371    | 0.24371    |   0.0 |  0.12
Other   |            | 0.03789    |            |       |  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:      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 = 253.07965075287, Press = -2.20591466603617
next a
jump SELF top
variable a loop 2000
run 1000
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   -8431.7341   -8431.7341   -8496.4065   -8496.4065    250.28911    250.28911    23747.585    23747.585    404.96562    404.96562 
   60000   -8428.7865   -8428.7865   -8494.9431   -8494.9431    256.03293    256.03293    23770.009    23770.009   -851.81021   -851.81021 
Loop time of 293.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.294 ns/day, 81.535 hours/ns, 3.407 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    | 293.04     | 293.04     | 293.04     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075713   | 0.075713   | 0.075713   |   0.0 |  0.03
Output  | 0.00028249 | 0.00028249 | 0.00028249 |   0.0 |  0.00
Modify  | 0.35431    | 0.35431    | 0.35431    |   0.0 |  0.12
Other   |            | 0.05247    |            |       |  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:      239286.0 ave      239286 max      239286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239286
Ave neighs/atom = 119.64300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
23757.3962540959

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0