# 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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -8484.2519   -8484.2519   -8559.9992   -8559.9992       293.15       293.15    23579.911    23579.911    3431.1916    3431.1916 
    1000   -8409.9041   -8409.9041   -8486.0727   -8486.0727    294.78024    294.78024    23738.435    23738.435    3073.9302    3073.9302 
Loop time of 140.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.137 hours/ns, 7.098 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    | 140.65     | 140.65     | 140.65     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039306   | 0.039306   | 0.039306   |   0.0 |  0.03
Output  | 0.00027431 | 0.00027431 | 0.00027431 |   0.0 |  0.00
Modify  | 0.17922    | 0.17922    | 0.17922    |   0.0 |  0.13
Other   |            | 0.02892    |            |       |  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   -8409.9041   -8409.9041   -8486.0727   -8486.0727    294.78024    294.78024    23738.435    23738.435    3073.9302    3073.9302 
    2000   -8407.2971   -8407.2971   -8481.8985   -8481.8985     288.7152     288.7152     23761.71     23761.71    1779.8716    1779.8716 
Loop time of 149.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.516 hours/ns, 6.691 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.21     | 149.21     | 149.21     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039965   | 0.039965   | 0.039965   |   0.0 |  0.03
Output  | 0.00012594 | 0.00012594 | 0.00012594 |   0.0 |  0.00
Modify  | 0.18138    | 0.18138    | 0.18138    |   0.0 |  0.12
Other   |            | 0.02959    |            |       |  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:      240330.0 ave      240330 max      240330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240330
Ave neighs/atom = 120.16500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8407.2971   -8407.2971   -8481.8985   -8481.8985     288.7152     288.7152     23761.71     23761.71    1779.8716    1779.8716 
    3000   -8410.2289   -8410.2289   -8484.8488   -8484.8488    288.78659    288.78659    23776.765    23776.765    518.26763    518.26763 
Loop time of 138.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.346 hours/ns, 7.244 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    | 137.81     | 137.81     | 137.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037246   | 0.037246   | 0.037246   |   0.0 |  0.03
Output  | 0.00011868 | 0.00011868 | 0.00011868 |   0.0 |  0.00
Modify  | 0.16729    | 0.16729    | 0.16729    |   0.0 |  0.12
Other   |            | 0.02819    |            |       |  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:      240068.0 ave      240068 max      240068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240068
Ave neighs/atom = 120.03400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8410.2289   -8410.2289   -8484.8488   -8484.8488    288.78659    288.78659    23776.765    23776.765    518.26763    518.26763 
    4000   -8407.0534   -8407.0534   -8481.0066   -8481.0066    286.20666    286.20666    23786.128    23786.128    289.63401    289.63401 
Loop time of 141.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.263 hours/ns, 7.075 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.11     | 141.11     | 141.11     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037797   | 0.037797   | 0.037797   |   0.0 |  0.03
Output  | 0.00011549 | 0.00011549 | 0.00011549 |   0.0 |  0.00
Modify  | 0.17282    | 0.17282    | 0.17282    |   0.0 |  0.12
Other   |            | 0.029      |            |       |  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:      239464.0 ave      239464 max      239464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239464
Ave neighs/atom = 119.73200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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   -8407.0534   -8407.0534   -8481.0066   -8481.0066    286.20666    286.20666    23786.128    23786.128    289.63401    289.63401 
    5000   -8410.8517   -8410.8517   -8484.9403   -8484.9403     286.7306     286.7306    23784.374    23784.374   -69.653759   -69.653759 
Loop time of 139.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.637 hours/ns, 7.190 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.86     | 138.86     | 138.86     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037557   | 0.037557   | 0.037557   |   0.0 |  0.03
Output  | 9.0287e-05 | 9.0287e-05 | 9.0287e-05 |   0.0 |  0.00
Modify  | 0.17037    | 0.17037    | 0.17037    |   0.0 |  0.12
Other   |            | 0.02807    |            |       |  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:      239616.0 ave      239616 max      239616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239616
Ave neighs/atom = 119.80800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 288.873231042844, Press = 1122.34923960118
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.8517   -8410.8517   -8484.9403   -8484.9403     286.7306     286.7306    23784.374    23784.374   -69.653759   -69.653759 
    6000   -8409.1129   -8409.1129    -8483.346    -8483.346    287.29004    287.29004    23801.029    23801.029   -1090.3562   -1090.3562 
Loop time of 140.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.971 hours/ns, 7.128 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.05     | 140.05     | 140.05     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037426   | 0.037426   | 0.037426   |   0.0 |  0.03
Output  | 8.4732e-05 | 8.4732e-05 | 8.4732e-05 |   0.0 |  0.00
Modify  | 0.17857    | 0.17857    | 0.17857    |   0.0 |  0.13
Other   |            | 0.02807    |            |       |  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:      239226.0 ave      239226 max      239226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239226
Ave neighs/atom = 119.61300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.199962872756, Press = 121.074848911739
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.1129   -8409.1129    -8483.346    -8483.346    287.29004    287.29004    23801.029    23801.029   -1090.3562   -1090.3562 
    7000   -8408.3438   -8408.3438   -8483.7123   -8483.7123    291.68396    291.68396    23826.024    23826.024   -2779.3086   -2779.3086 
Loop time of 139.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.757 hours/ns, 7.167 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    | 139.28     | 139.28     | 139.28     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037398   | 0.037398   | 0.037398   |   0.0 |  0.03
Output  | 8.69e-05   | 8.69e-05   | 8.69e-05   |   0.0 |  0.00
Modify  | 0.17734    | 0.17734    | 0.17734    |   0.0 |  0.13
Other   |            | 0.0275     |            |       |  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:      239276.0 ave      239276 max      239276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239276
Ave neighs/atom = 119.63800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.959475226399, Press = 58.7401190390609
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.3438   -8408.3438   -8483.7123   -8483.7123    291.68396    291.68396    23826.024    23826.024   -2779.3086   -2779.3086 
    8000   -8406.1675   -8406.1675   -8484.1222   -8484.1222    301.69291    301.69291    23808.933    23808.933   -1463.5491   -1463.5491 
Loop time of 143.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.601 ns/day, 39.906 hours/ns, 6.961 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    | 143.41     | 143.41     | 143.41     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038066   | 0.038066   | 0.038066   |   0.0 |  0.03
Output  | 8.9784e-05 | 8.9784e-05 | 8.9784e-05 |   0.0 |  0.00
Modify  | 0.18321    | 0.18321    | 0.18321    |   0.0 |  0.13
Other   |            | 0.02798    |            |       |  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:      238690.0 ave      238690 max      238690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238690
Ave neighs/atom = 119.34500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.977364024898, Press = 24.9656118673531
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.1675   -8406.1675   -8484.1222   -8484.1222    301.69291    301.69291    23808.933    23808.933   -1463.5491   -1463.5491 
    9000   -8408.1919   -8408.1919   -8484.8704   -8484.8704    296.75383    296.75383    23802.882    23802.882   -1181.6684   -1181.6684 
Loop time of 155.737 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.555 ns/day, 43.260 hours/ns, 6.421 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    | 155.47     | 155.47     | 155.47     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041432   | 0.041432   | 0.041432   |   0.0 |  0.03
Output  | 0.00011358 | 0.00011358 | 0.00011358 |   0.0 |  0.00
Modify  | 0.19834    | 0.19834    | 0.19834    |   0.0 |  0.13
Other   |            | 0.03068    |            |       |  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:      238928.0 ave      238928 max      238928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238928
Ave neighs/atom = 119.46400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.608247471766, Press = 16.0744345155393
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.1919   -8408.1919   -8484.8704   -8484.8704    296.75383    296.75383    23802.882    23802.882   -1181.6684   -1181.6684 
   10000   -8410.7206   -8410.7206   -8485.4275   -8485.4275    289.12356    289.12356    23805.362    23805.362   -1584.9516   -1584.9516 
Loop time of 143.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.603 ns/day, 39.784 hours/ns, 6.982 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.98     | 142.98     | 142.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038051   | 0.038051   | 0.038051   |   0.0 |  0.03
Output  | 9.1713e-05 | 9.1713e-05 | 9.1713e-05 |   0.0 |  0.00
Modify  | 0.18225    | 0.18225    | 0.18225    |   0.0 |  0.13
Other   |            | 0.02858    |            |       |  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:      239188.0 ave      239188 max      239188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239188
Ave neighs/atom = 119.59400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.658572389066, Press = 10.6404582700262
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.7206   -8410.7206   -8485.4275   -8485.4275    289.12356    289.12356    23805.362    23805.362   -1584.9516   -1584.9516 
   11000   -8407.0564   -8407.0564   -8484.0112   -8484.0112    297.82283    297.82283    23816.676    23816.676   -2027.4596   -2027.4596 
Loop time of 149.542 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.28     | 149.28     | 149.28     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040132   | 0.040132   | 0.040132   |   0.0 |  0.03
Output  | 9.8831e-05 | 9.8831e-05 | 9.8831e-05 |   0.0 |  0.00
Modify  | 0.19238    | 0.19238    | 0.19238    |   0.0 |  0.13
Other   |            | 0.02995    |            |       |  0.02

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

Total # of neighbors = 239098
Ave neighs/atom = 119.54900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.684227786269, Press = 8.31872384680032
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.0564   -8407.0564   -8484.0112   -8484.0112    297.82283    297.82283    23816.676    23816.676   -2027.4596   -2027.4596 
   12000   -8407.0372   -8407.0372   -8482.3852   -8482.3852    291.60458    291.60458    23847.174    23847.174   -3919.8887   -3919.8887 
Loop time of 139.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.672 hours/ns, 7.183 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    | 138.98     | 138.98     | 138.98     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037225   | 0.037225   | 0.037225   |   0.0 |  0.03
Output  | 8.5396e-05 | 8.5396e-05 | 8.5396e-05 |   0.0 |  0.00
Modify  | 0.17588    | 0.17588    | 0.17588    |   0.0 |  0.13
Other   |            | 0.02779    |            |       |  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:      238948.0 ave      238948 max      238948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238948
Ave neighs/atom = 119.47400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.453451704228, Press = 3.45387308091624
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.0372   -8407.0372   -8482.3852   -8482.3852    291.60458    291.60458    23847.174    23847.174   -3919.8887   -3919.8887 
   13000   -8408.4116   -8408.4116   -8483.7786   -8483.7786    291.67835    291.67835    23836.344    23836.344   -3288.3226   -3288.3226 
Loop time of 148.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.129 hours/ns, 6.754 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    | 147.81     | 147.81     | 147.81     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039386   | 0.039386   | 0.039386   |   0.0 |  0.03
Output  | 9.2946e-05 | 9.2946e-05 | 9.2946e-05 |   0.0 |  0.00
Modify  | 0.18906    | 0.18906    | 0.18906    |   0.0 |  0.13
Other   |            | 0.02917    |            |       |  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:      238526.0 ave      238526 max      238526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238526
Ave neighs/atom = 119.26300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.405661423483, Press = 0.410218858055672
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.4116   -8408.4116   -8483.7786   -8483.7786    291.67835    291.67835    23836.344    23836.344   -3288.3226   -3288.3226 
   14000   -8409.7361   -8409.7361   -8483.8361   -8483.8361    286.77453    286.77453    23805.191    23805.191   -1235.6208   -1235.6208 
Loop time of 151.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.570 ns/day, 42.117 hours/ns, 6.595 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    | 151.36     | 151.36     | 151.36     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040801   | 0.040801   | 0.040801   |   0.0 |  0.03
Output  | 9.9497e-05 | 9.9497e-05 | 9.9497e-05 |   0.0 |  0.00
Modify  | 0.19284    | 0.19284    | 0.19284    |   0.0 |  0.13
Other   |            | 0.02998    |            |       |  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:      238488.0 ave      238488 max      238488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238488
Ave neighs/atom = 119.24400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.327970806172, Press = 0.535031192576748
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.7361   -8409.7361   -8483.8361   -8483.8361    286.77453    286.77453    23805.191    23805.191   -1235.6208   -1235.6208 
   15000   -8405.8158   -8405.8158   -8482.0025   -8482.0025    294.85053    294.85053    23799.474    23799.474   -448.77418   -448.77418 
Loop time of 155.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.556 ns/day, 43.201 hours/ns, 6.430 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    | 155.25     | 155.25     | 155.25     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041663   | 0.041663   | 0.041663   |   0.0 |  0.03
Output  | 0.00036164 | 0.00036164 | 0.00036164 |   0.0 |  0.00
Modify  | 0.19752    | 0.19752    | 0.19752    |   0.0 |  0.13
Other   |            | 0.03139    |            |       |  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:      239194.0 ave      239194 max      239194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239194
Ave neighs/atom = 119.59700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.325064515293, Press = 2.3238820880462
next a
jump SELF top
variable a loop 2000
run 1000
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   -8405.8158   -8405.8158   -8482.0025   -8482.0025    294.85053    294.85053    23799.474    23799.474   -448.77418   -448.77418 
   16000    -8409.594    -8409.594   -8486.8378   -8486.8378     298.9414     298.9414    23786.658    23786.658   -298.17119   -298.17119 
Loop time of 161.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.534 ns/day, 44.984 hours/ns, 6.175 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    | 161.66     | 161.66     | 161.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043485   | 0.043485   | 0.043485   |   0.0 |  0.03
Output  | 9.5502e-05 | 9.5502e-05 | 9.5502e-05 |   0.0 |  0.00
Modify  | 0.20713    | 0.20713    | 0.20713    |   0.0 |  0.13
Other   |            | 0.03255    |            |       |  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:      239002.0 ave      239002 max      239002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239002
Ave neighs/atom = 119.50100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.517552257273, Press = 2.8179499767587
next a
jump SELF top
variable a loop 2000
run 1000
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    -8409.594    -8409.594   -8486.8378   -8486.8378     298.9414     298.9414    23786.658    23786.658   -298.17119   -298.17119 
   17000   -8410.7104   -8410.7104   -8486.2549   -8486.2549    292.36524    292.36524    23776.282    23776.282    497.58806    497.58806 
Loop time of 148.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.184 hours/ns, 6.745 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148        | 148        | 148        |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039198   | 0.039198   | 0.039198   |   0.0 |  0.03
Output  | 0.00010151 | 0.00010151 | 0.00010151 |   0.0 |  0.00
Modify  | 0.18973    | 0.18973    | 0.18973    |   0.0 |  0.13
Other   |            | 0.02985    |            |       |  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:      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"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.540482559888, Press = 2.67375766007463
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.7104   -8410.7104   -8486.2549   -8486.2549    292.36524    292.36524    23776.282    23776.282    497.58806    497.58806 
   18000   -8406.7483   -8406.7483   -8483.0975   -8483.0975    295.47919    295.47919     23759.82     23759.82    2053.3307    2053.3307 
Loop time of 137.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.259 hours/ns, 7.261 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.49     | 137.49     | 137.49     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037021   | 0.037021   | 0.037021   |   0.0 |  0.03
Output  | 8.9252e-05 | 8.9252e-05 | 8.9252e-05 |   0.0 |  0.00
Modify  | 0.17502    | 0.17502    | 0.17502    |   0.0 |  0.13
Other   |            | 0.02841    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239496.0 ave      239496 max      239496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239496
Ave neighs/atom = 119.74800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470237946093, Press = 2.37052527407157
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.7483   -8406.7483   -8483.0975   -8483.0975    295.47919    295.47919     23759.82     23759.82    2053.3307    2053.3307 
   19000   -8408.6482   -8408.6482    -8482.854    -8482.854    287.18409    287.18409    23731.916    23731.916    3952.1023    3952.1023 
Loop time of 135.503 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.640 hours/ns, 7.380 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.27     | 135.27     | 135.27     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036545   | 0.036545   | 0.036545   |   0.0 |  0.03
Output  | 8.9261e-05 | 8.9261e-05 | 8.9261e-05 |   0.0 |  0.00
Modify  | 0.17146    | 0.17146    | 0.17146    |   0.0 |  0.13
Other   |            | 0.02778    |            |       |  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:      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 = 293.435631523788, Press = 2.34967979338327
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.6482   -8408.6482    -8482.854    -8482.854    287.18409    287.18409    23731.916    23731.916    3952.1023    3952.1023 
   20000    -8407.517    -8407.517   -8483.0025   -8483.0025     292.1369     292.1369    23745.525    23745.525    3025.5202    3025.5202 
Loop time of 137.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.287 hours/ns, 7.255 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.59     | 137.59     | 137.59     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037263   | 0.037263   | 0.037263   |   0.0 |  0.03
Output  | 8.6081e-05 | 8.6081e-05 | 8.6081e-05 |   0.0 |  0.00
Modify  | 0.17547    | 0.17547    | 0.17547    |   0.0 |  0.13
Other   |            | 0.02845    |            |       |  0.02

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

Total # of neighbors = 240522
Ave neighs/atom = 120.26100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.460434254559, Press = 4.6132570618638
next a
jump SELF top
variable a loop 2000
run 1000
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    -8407.517    -8407.517   -8483.0025   -8483.0025     292.1369     292.1369    23745.525    23745.525    3025.5202    3025.5202 
   21000   -8406.3131   -8406.3131    -8484.113    -8484.113    301.09367    301.09367    23771.523    23771.523    1199.2672    1199.2672 
Loop time of 158.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.995 hours/ns, 6.314 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    | 158.11     | 158.11     | 158.11     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042035   | 0.042035   | 0.042035   |   0.0 |  0.03
Output  | 8.8392e-05 | 8.8392e-05 | 8.8392e-05 |   0.0 |  0.00
Modify  | 0.20032    | 0.20032    | 0.20032    |   0.0 |  0.13
Other   |            | 0.03178    |            |       |  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:      240172.0 ave      240172 max      240172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240172
Ave neighs/atom = 120.08600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.377643017001, Press = 5.17584408763305
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.3131   -8406.3131    -8484.113    -8484.113    301.09367    301.09367    23771.523    23771.523    1199.2672    1199.2672 
   22000   -8409.3594   -8409.3594   -8484.2488   -8484.2488    289.82955    289.82955    23768.833    23768.833    1134.9379    1134.9379 
Loop time of 138.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.585 hours/ns, 7.199 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    | 138.66     | 138.66     | 138.66     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037325   | 0.037325   | 0.037325   |   0.0 |  0.03
Output  | 8.6586e-05 | 8.6586e-05 | 8.6586e-05 |   0.0 |  0.00
Modify  | 0.17704    | 0.17704    | 0.17704    |   0.0 |  0.13
Other   |            | 0.02849    |            |       |  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:      239534.0 ave      239534 max      239534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239534
Ave neighs/atom = 119.76700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.378392733111, Press = 5.25578759261871
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.3594   -8409.3594   -8484.2488   -8484.2488    289.82955    289.82955    23768.833    23768.833    1134.9379    1134.9379 
   23000   -8407.3205   -8407.3205   -8483.3772   -8483.3772     294.3474     294.3474    23775.583    23775.583    876.26327    876.26327 
Loop time of 142.167 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.92     | 141.92     | 141.92     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038281   | 0.038281   | 0.038281   |   0.0 |  0.03
Output  | 8.6062e-05 | 8.6062e-05 | 8.6062e-05 |   0.0 |  0.00
Modify  | 0.18137    | 0.18137    | 0.18137    |   0.0 |  0.13
Other   |            | 0.02914    |            |       |  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:      239822.0 ave      239822 max      239822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239822
Ave neighs/atom = 119.91100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.468389075243, Press = 5.70059262055016
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.3205   -8407.3205   -8483.3772   -8483.3772     294.3474     294.3474    23775.583    23775.583    876.26327    876.26327 
   24000    -8408.499    -8408.499   -8484.0757   -8484.0757    292.48963    292.48963     23777.94     23777.94    586.15115    586.15115 
Loop time of 205.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.420 ns/day, 57.125 hours/ns, 4.863 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    | 205.29     | 205.29     | 205.29     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05535    | 0.05535    | 0.05535    |   0.0 |  0.03
Output  | 0.00016116 | 0.00016116 | 0.00016116 |   0.0 |  0.00
Modify  | 0.2653     | 0.2653     | 0.2653     |   0.0 |  0.13
Other   |            | 0.04264    |            |       |  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:      239458.0 ave      239458 max      239458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239458
Ave neighs/atom = 119.72900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470251253292, Press = 5.64337374344382
next a
jump SELF top
variable a loop 2000
run 1000
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    -8408.499    -8408.499   -8484.0757   -8484.0757    292.48963    292.48963     23777.94     23777.94    586.15115    586.15115 
   25000   -8407.0254   -8407.0254   -8482.3617   -8482.3617    291.55934    291.55934    23790.279    23790.279   -14.638785   -14.638785 
Loop time of 230.57 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.047 hours/ns, 4.337 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.17     | 230.17     | 230.17     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062478   | 0.062478   | 0.062478   |   0.0 |  0.03
Output  | 0.00023818 | 0.00023818 | 0.00023818 |   0.0 |  0.00
Modify  | 0.29476    | 0.29476    | 0.29476    |   0.0 |  0.13
Other   |            | 0.04496    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4128.00 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 293.613834624267, Press = 5.84902086290391
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.0254   -8407.0254   -8482.3617   -8482.3617    291.55934    291.55934    23790.279    23790.279   -14.638785   -14.638785 
   26000   -8408.8018   -8408.8018   -8483.1135   -8483.1135     287.5938     287.5938    23806.931    23806.931   -1238.1478   -1238.1478 
Loop time of 275.701 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.313 ns/day, 76.584 hours/ns, 3.627 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    | 275.24     | 275.24     | 275.24     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072516   | 0.072516   | 0.072516   |   0.0 |  0.03
Output  | 0.00016526 | 0.00016526 | 0.00016526 |   0.0 |  0.00
Modify  | 0.3403     | 0.3403     | 0.3403     |   0.0 |  0.12
Other   |            | 0.04882    |            |       |  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:      239342.0 ave      239342 max      239342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239342
Ave neighs/atom = 119.67100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.662812399968, Press = 6.12350816425009
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.8018   -8408.8018   -8483.1135   -8483.1135     287.5938     287.5938    23806.931    23806.931   -1238.1478   -1238.1478 
   27000   -8409.6726   -8409.6726   -8484.1733   -8484.1733    288.32551    288.32551     23820.31     23820.31   -2351.0194   -2351.0194 
Loop time of 221.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.389 ns/day, 61.651 hours/ns, 4.506 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    | 221.56     | 221.56     | 221.56     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.059835   | 0.059835   | 0.059835   |   0.0 |  0.03
Output  | 0.0001821  | 0.0001821  | 0.0001821  |   0.0 |  0.00
Modify  | 0.28261    | 0.28261    | 0.28261    |   0.0 |  0.13
Other   |            | 0.0431     |            |       |  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:      238992.0 ave      238992 max      238992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238992
Ave neighs/atom = 119.49600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.655484934944, Press = 6.41407658846383
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.6726   -8409.6726   -8484.1733   -8484.1733    288.32551    288.32551     23820.31     23820.31   -2351.0194   -2351.0194 
   28000   -8410.7252   -8410.7252   -8486.4996   -8486.4996    293.25482    293.25482    23817.899    23817.899    -2438.089    -2438.089 
Loop time of 199.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.516 hours/ns, 5.004 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.51     | 199.51     | 199.51     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054729   | 0.054729   | 0.054729   |   0.0 |  0.03
Output  | 0.00018917 | 0.00018917 | 0.00018917 |   0.0 |  0.00
Modify  | 0.25811    | 0.25811    | 0.25811    |   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:        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:      238772.0 ave      238772 max      238772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238772
Ave neighs/atom = 119.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.49938547551, Press = 4.49472783182485
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.7252   -8410.7252   -8486.4996   -8486.4996    293.25482    293.25482    23817.899    23817.899    -2438.089    -2438.089 
   29000   -8409.6341   -8409.6341    -8483.493    -8483.493    285.84158    285.84158     23802.43     23802.43   -1074.8893   -1074.8893 
Loop time of 195.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.443 ns/day, 54.198 hours/ns, 5.125 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    | 194.77     | 194.77     | 194.77     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052822   | 0.052822   | 0.052822   |   0.0 |  0.03
Output  | 9.7192e-05 | 9.7192e-05 | 9.7192e-05 |   0.0 |  0.00
Modify  | 0.25114    | 0.25114    | 0.25114    |   0.0 |  0.13
Other   |            | 0.03956    |            |       |  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:      238494.0 ave      238494 max      238494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238494
Ave neighs/atom = 119.24700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.514899878633, Press = 3.13958693514053
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.6341   -8409.6341    -8483.493    -8483.493    285.84158    285.84158     23802.43     23802.43   -1074.8893   -1074.8893 
   30000   -8404.9739   -8404.9739   -8484.2586   -8484.2586    306.84015    306.84015    23812.253    23812.253   -1566.2056   -1566.2056 
Loop time of 148.875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.354 hours/ns, 6.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.61     | 148.61     | 148.61     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039539   | 0.039539   | 0.039539   |   0.0 |  0.03
Output  | 0.0002082  | 0.0002082  | 0.0002082  |   0.0 |  0.00
Modify  | 0.19133    | 0.19133    | 0.19133    |   0.0 |  0.13
Other   |            | 0.02977    |            |       |  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:      239126.0 ave      239126 max      239126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239126
Ave neighs/atom = 119.56300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.591002962139, Press = 2.29208282173078
next a
jump SELF top
variable a loop 2000
run 1000
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   -8404.9739   -8404.9739   -8484.2586   -8484.2586    306.84015    306.84015    23812.253    23812.253   -1566.2056   -1566.2056 
   31000   -8410.0459   -8410.0459   -8484.5306   -8484.5306    288.26349    288.26349    23806.849    23806.849    -1395.971    -1395.971 
Loop time of 143.6 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.602 ns/day, 39.889 hours/ns, 6.964 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    | 143.35     | 143.35     | 143.35     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038153   | 0.038153   | 0.038153   |   0.0 |  0.03
Output  | 9.5128e-05 | 9.5128e-05 | 9.5128e-05 |   0.0 |  0.00
Modify  | 0.18526    | 0.18526    | 0.18526    |   0.0 |  0.13
Other   |            | 0.02854    |            |       |  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:      238936.0 ave      238936 max      238936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238936
Ave neighs/atom = 119.46800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.665237087355, Press = 1.86702434540528
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.0459   -8410.0459   -8484.5306   -8484.5306    288.26349    288.26349    23806.849    23806.849    -1395.971    -1395.971 
   32000   -8410.1824   -8410.1824   -8484.7627   -8484.7627     288.6337     288.6337    23819.898    23819.898   -2419.2063   -2419.2063 
Loop time of 143.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.602 ns/day, 39.880 hours/ns, 6.965 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    | 143.32     | 143.32     | 143.32     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037876   | 0.037876   | 0.037876   |   0.0 |  0.03
Output  | 0.00010219 | 0.00010219 | 0.00010219 |   0.0 |  0.00
Modify  | 0.18419    | 0.18419    | 0.18419    |   0.0 |  0.13
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:        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:      238918.0 ave      238918 max      238918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238918
Ave neighs/atom = 119.45900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.673626433769, Press = 0.819145452568203
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.1824   -8410.1824   -8484.7627   -8484.7627     288.6337     288.6337    23819.898    23819.898   -2419.2063   -2419.2063 
   33000   -8410.6592   -8410.6592   -8487.5862   -8487.5862    297.71527    297.71527    23827.632    23827.632    -3232.215    -3232.215 
Loop time of 143.058 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.81     | 142.81     | 142.81     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03824    | 0.03824    | 0.03824    |   0.0 |  0.03
Output  | 9.3558e-05 | 9.3558e-05 | 9.3558e-05 |   0.0 |  0.00
Modify  | 0.18397    | 0.18397    | 0.18397    |   0.0 |  0.13
Other   |            | 0.0288     |            |       |  0.02

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

Total # of neighbors = 238772
Ave neighs/atom = 119.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.576503819584, Press = -0.628113409526766
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.6592   -8410.6592   -8487.5862   -8487.5862    297.71527    297.71527    23827.632    23827.632    -3232.215    -3232.215 
   34000   -8410.4219   -8410.4219   -8483.4902   -8483.4902    282.78172    282.78172    23794.726    23794.726   -569.44468   -569.44468 
Loop time of 141.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.288 hours/ns, 7.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.19     | 141.19     | 141.19     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037808   | 0.037808   | 0.037808   |   0.0 |  0.03
Output  | 0.00010197 | 0.00010197 | 0.00010197 |   0.0 |  0.00
Modify  | 0.18099    | 0.18099    | 0.18099    |   0.0 |  0.13
Other   |            | 0.02849    |            |       |  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:      238374.0 ave      238374 max      238374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 238374
Ave neighs/atom = 119.18700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.542335050261, Press = 0.151403591284731
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.4219   -8410.4219   -8483.4902   -8483.4902    282.78172    282.78172    23794.726    23794.726   -569.44468   -569.44468 
   35000   -8406.8417   -8406.8417   -8483.5137   -8483.5137    296.72839    296.72839    23792.802    23792.802   -334.23471   -334.23471 
Loop time of 155.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.557 ns/day, 43.057 hours/ns, 6.451 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.73     | 154.73     | 154.73     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041626   | 0.041626   | 0.041626   |   0.0 |  0.03
Output  | 0.00010162 | 0.00010162 | 0.00010162 |   0.0 |  0.00
Modify  | 0.19839    | 0.19839    | 0.19839    |   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:        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:      239200.0 ave      239200 max      239200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239200
Ave neighs/atom = 119.60000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.563430251017, Press = 0.675239030075883
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.8417   -8406.8417   -8483.5137   -8483.5137    296.72839    296.72839    23792.802    23792.802   -334.23471   -334.23471 
   36000    -8408.153    -8408.153   -8484.6655   -8484.6655    296.11111    296.11111    23785.869    23785.869    57.869364    57.869364 
Loop time of 158.181 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.939 hours/ns, 6.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.9      | 157.9      | 157.9      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042582   | 0.042582   | 0.042582   |   0.0 |  0.03
Output  | 9.4619e-05 | 9.4619e-05 | 9.4619e-05 |   0.0 |  0.00
Modify  | 0.20301    | 0.20301    | 0.20301    |   0.0 |  0.13
Other   |            | 0.03211    |            |       |  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:      239292.0 ave      239292 max      239292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239292
Ave neighs/atom = 119.64600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.572508910712, Press = 0.329087775158891
next a
jump SELF top
variable a loop 2000
run 1000
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    -8408.153    -8408.153   -8484.6655   -8484.6655    296.11111    296.11111    23785.869    23785.869    57.869364    57.869364 
   37000   -8407.2231   -8407.2231    -8482.761    -8482.761    292.33916    292.33916     23777.64     23777.64    753.24859    753.24859 
Loop time of 143.848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.601 ns/day, 39.958 hours/ns, 6.952 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    | 143.6      | 143.6      | 143.6      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038321   | 0.038321   | 0.038321   |   0.0 |  0.03
Output  | 9.5275e-05 | 9.5275e-05 | 9.5275e-05 |   0.0 |  0.00
Modify  | 0.18539    | 0.18539    | 0.18539    |   0.0 |  0.13
Other   |            | 0.02923    |            |       |  0.02

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

Total # of neighbors = 239110
Ave neighs/atom = 119.55500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.654192259885, Press = 0.263498660394077
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.2231   -8407.2231    -8482.761    -8482.761    292.33916    292.33916     23777.64     23777.64    753.24859    753.24859 
   38000   -8407.3117   -8407.3117   -8482.9889   -8482.9889    292.87862    292.87862    23758.297    23758.297    2143.1372    2143.1372 
Loop time of 149.869 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.61     | 149.61     | 149.61     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040247   | 0.040247   | 0.040247   |   0.0 |  0.03
Output  | 0.00010739 | 0.00010739 | 0.00010739 |   0.0 |  0.00
Modify  | 0.19202    | 0.19202    | 0.19202    |   0.0 |  0.13
Other   |            | 0.03041    |            |       |  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:      239508.0 ave      239508 max      239508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239508
Ave neighs/atom = 119.75400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.615528842016, Press = 0.875155361943439
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.3117   -8407.3117   -8482.9889   -8482.9889    292.87862    292.87862    23758.297    23758.297    2143.1372    2143.1372 
   39000   -8411.2842   -8411.2842   -8486.8523   -8486.8523    292.45628    292.45628    23733.544    23733.544    3220.6284    3220.6284 
Loop time of 195.803 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.390 hours/ns, 5.107 timesteps/s
89.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    | 195.43     | 195.43     | 195.43     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073178   | 0.073178   | 0.073178   |   0.0 |  0.04
Output  | 9.4304e-05 | 9.4304e-05 | 9.4304e-05 |   0.0 |  0.00
Modify  | 0.25206    | 0.25206    | 0.25206    |   0.0 |  0.13
Other   |            | 0.04893    |            |       |  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:      240008.0 ave      240008 max      240008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240008
Ave neighs/atom = 120.00400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.567185778591, Press = 1.68770695839996
next a
jump SELF top
variable a loop 2000
run 1000
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   -8411.2842   -8411.2842   -8486.8523   -8486.8523    292.45628    292.45628    23733.544    23733.544    3220.6284    3220.6284 
   40000   -8406.3841   -8406.3841   -8484.5239   -8484.5239    302.40894    302.40894    23735.075    23735.075    3703.9944    3703.9944 
Loop time of 155.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.555 ns/day, 43.278 hours/ns, 6.418 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    | 155.53     | 155.53     | 155.53     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04221    | 0.04221    | 0.04221    |   0.0 |  0.03
Output  | 0.00027403 | 0.00027403 | 0.00027403 |   0.0 |  0.00
Modify  | 0.20156    | 0.20156    | 0.20156    |   0.0 |  0.13
Other   |            | 0.0322     |            |       |  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:      240178.0 ave      240178 max      240178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240178
Ave neighs/atom = 120.08900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.538655519614, Press = 2.86276842484983
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.3841   -8406.3841   -8484.5239   -8484.5239    302.40894    302.40894    23735.075    23735.075    3703.9944    3703.9944 
   41000    -8409.731    -8409.731   -8485.1833   -8485.1833    292.00818    292.00818    23765.216    23765.216    1347.7111    1347.7111 
Loop time of 143.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.602 ns/day, 39.879 hours/ns, 6.965 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    | 143.31     | 143.31     | 143.31     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038664   | 0.038664   | 0.038664   |   0.0 |  0.03
Output  | 0.00031888 | 0.00031888 | 0.00031888 |   0.0 |  0.00
Modify  | 0.18292    | 0.18292    | 0.18292    |   0.0 |  0.13
Other   |            | 0.0295     |            |       |  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:      240178.0 ave      240178 max      240178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 240178
Ave neighs/atom = 120.08900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.53400069668, Press = 2.68702440650874
next a
jump SELF top
variable a loop 2000
run 1000
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    -8409.731    -8409.731   -8485.1833   -8485.1833    292.00818    292.00818    23765.216    23765.216    1347.7111    1347.7111 
   42000   -8407.2111   -8407.2111   -8483.5738   -8483.5738    295.53179    295.53179    23778.849    23778.849    671.09108    671.09108 
Loop time of 172.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.053 hours/ns, 5.781 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    | 172.68     | 172.68     | 172.68     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047237   | 0.047237   | 0.047237   |   0.0 |  0.03
Output  | 8.3263e-05 | 8.3263e-05 | 8.3263e-05 |   0.0 |  0.00
Modify  | 0.22614    | 0.22614    | 0.22614    |   0.0 |  0.13
Other   |            | 0.03652    |            |       |  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:      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 = 293.514885040653, Press = 2.46721523241157
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.2111   -8407.2111   -8483.5738   -8483.5738    295.53179    295.53179    23778.849    23778.849    671.09108    671.09108 
   43000   -8410.2687   -8410.2687   -8485.7619   -8485.7619    292.16666    292.16666    23779.998    23779.998    151.51599    151.51599 
Loop time of 178.932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.703 hours/ns, 5.589 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.61     | 178.61     | 178.61     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049411   | 0.049411   | 0.049411   |   0.0 |  0.03
Output  | 0.00015101 | 0.00015101 | 0.00015101 |   0.0 |  0.00
Modify  | 0.23232    | 0.23232    | 0.23232    |   0.0 |  0.13
Other   |            | 0.0384     |            |       |  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:      239524.0 ave      239524 max      239524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239524
Ave neighs/atom = 119.76200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509462154816, Press = 2.32188165822803
next a
jump SELF top
variable a loop 2000
run 1000
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   -8410.2687   -8410.2687   -8485.7619   -8485.7619    292.16666    292.16666    23779.998    23779.998    151.51599    151.51599 
   44000   -8407.1812   -8407.1812   -8484.4679   -8484.4679    299.10754    299.10754    23796.867    23796.867    -709.4822    -709.4822 
Loop time of 167.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.515 ns/day, 46.572 hours/ns, 5.964 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    | 167.36     | 167.36     | 167.36     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046159   | 0.046159   | 0.046159   |   0.0 |  0.03
Output  | 0.00010054 | 0.00010054 | 0.00010054 |   0.0 |  0.00
Modify  | 0.22012    | 0.22012    | 0.22012    |   0.0 |  0.13
Other   |            | 0.03714    |            |       |  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:      239402.0 ave      239402 max      239402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239402
Ave neighs/atom = 119.70100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.480011083617, Press = 3.53341904133152
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.1812   -8407.1812   -8484.4679   -8484.4679    299.10754    299.10754    23796.867    23796.867    -709.4822    -709.4822 
   45000   -8409.8367   -8409.8367   -8485.3344   -8485.3344    292.18392    292.18392    23813.949    23813.949   -2043.0451   -2043.0451 
Loop time of 137.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.628 ns/day, 38.212 hours/ns, 7.269 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.32     | 137.32     | 137.32     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037074   | 0.037074   | 0.037074   |   0.0 |  0.03
Output  | 9.5845e-05 | 9.5845e-05 | 9.5845e-05 |   0.0 |  0.00
Modify  | 0.17574    | 0.17574    | 0.17574    |   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:      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 = 293.523585333658, Press = 3.68080547126635
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.8367   -8409.8367   -8485.3344   -8485.3344    292.18392    292.18392    23813.949    23813.949   -2043.0451   -2043.0451 
   46000   -8408.6074   -8408.6074   -8484.4934   -8484.4934    293.68664    293.68664    23818.479    23818.479   -2215.5889   -2215.5889 
Loop time of 139.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.741 hours/ns, 7.170 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    | 139.22     | 139.22     | 139.22     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037384   | 0.037384   | 0.037384   |   0.0 |  0.03
Output  | 8.928e-05  | 8.928e-05  | 8.928e-05  |   0.0 |  0.00
Modify  | 0.17867    | 0.17867    | 0.17867    |   0.0 |  0.13
Other   |            | 0.02886    |            |       |  0.02

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

Total # of neighbors = 238974
Ave neighs/atom = 119.48700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.539909285563, Press = 2.5688598682001
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.6074   -8408.6074   -8484.4934   -8484.4934    293.68664    293.68664    23818.479    23818.479   -2215.5889   -2215.5889 
   47000   -8409.9278   -8409.9278   -8485.6566   -8485.6566    293.07864    293.07864     23811.39     23811.39   -2007.3729   -2007.3729 
Loop time of 137.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.629 ns/day, 38.163 hours/ns, 7.279 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.14     | 137.14     | 137.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037532   | 0.037532   | 0.037532   |   0.0 |  0.03
Output  | 9.2382e-05 | 9.2382e-05 | 9.2382e-05 |   0.0 |  0.00
Modify  | 0.17761    | 0.17761    | 0.17761    |   0.0 |  0.13
Other   |            | 0.02864    |            |       |  0.02

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

Total # of neighbors = 238754
Ave neighs/atom = 119.37700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472945060749, Press = 1.98738234184552
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.9278   -8409.9278   -8485.6566   -8485.6566    293.07864    293.07864     23811.39     23811.39   -2007.3729   -2007.3729 
   48000   -8409.8201   -8409.8201    -8484.939    -8484.939    290.71809    290.71809    23808.992    23808.992   -1713.6379   -1713.6379 
Loop time of 142.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.606 ns/day, 39.626 hours/ns, 7.010 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.4      | 142.4      | 142.4      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038276   | 0.038276   | 0.038276   |   0.0 |  0.03
Output  | 9.6832e-05 | 9.6832e-05 | 9.6832e-05 |   0.0 |  0.00
Modify  | 0.18452    | 0.18452    | 0.18452    |   0.0 |  0.13
Other   |            | 0.02887    |            |       |  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:      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 = 293.435528227908, Press = 1.37105305589471
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.8201   -8409.8201    -8484.939    -8484.939    290.71809    290.71809    23808.992    23808.992   -1713.6379   -1713.6379 
   49000   -8408.2658   -8408.2658   -8483.7294   -8483.7294    292.05203    292.05203    23805.687    23805.687   -1263.5781   -1263.5781 
Loop time of 145.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.592 ns/day, 40.538 hours/ns, 6.852 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    | 145.68     | 145.68     | 145.68     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038941   | 0.038941   | 0.038941   |   0.0 |  0.03
Output  | 0.00025897 | 0.00025897 | 0.00025897 |   0.0 |  0.00
Modify  | 0.1882     | 0.1882     | 0.1882     |   0.0 |  0.13
Other   |            | 0.02939    |            |       |  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:      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 = 293.39037735903, Press = 1.26193133876304
next a
jump SELF top
variable a loop 2000
run 1000
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   -8408.2658   -8408.2658   -8483.7294   -8483.7294    292.05203    292.05203    23805.687    23805.687   -1263.5781   -1263.5781 
   50000   -8413.7936   -8413.7936   -8486.5101   -8486.5101    281.42033    281.42033    23787.763    23787.763   -587.88014   -587.88014 
Loop time of 141.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.610 ns/day, 39.364 hours/ns, 7.057 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.46     | 141.46     | 141.46     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03796    | 0.03796    | 0.03796    |   0.0 |  0.03
Output  | 9.1469e-05 | 9.1469e-05 | 9.1469e-05 |   0.0 |  0.00
Modify  | 0.18283    | 0.18283    | 0.18283    |   0.0 |  0.13
Other   |            | 0.0297     |            |       |  0.02

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

Total # of neighbors = 239090
Ave neighs/atom = 119.54500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.351895193931, Press = 1.26079798297714
next a
jump SELF top
variable a loop 2000
run 1000
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   -8413.7936   -8413.7936   -8486.5101   -8486.5101    281.42033    281.42033    23787.763    23787.763   -587.88014   -587.88014 
   51000   -8407.3747   -8407.3747   -8482.9099   -8482.9099    292.32891    292.32891     23794.77     23794.77   -492.55352   -492.55352 
Loop time of 140.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.614 ns/day, 39.065 hours/ns, 7.111 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.39     | 140.39     | 140.39     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037625   | 0.037625   | 0.037625   |   0.0 |  0.03
Output  | 0.00010169 | 0.00010169 | 0.00010169 |   0.0 |  0.00
Modify  | 0.18083    | 0.18083    | 0.18083    |   0.0 |  0.13
Other   |            | 0.029      |            |       |  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:      239186.0 ave      239186 max      239186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239186
Ave neighs/atom = 119.59300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.318320267444, Press = 1.41298407096055
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.3747   -8407.3747   -8482.9099   -8482.9099    292.32891    292.32891     23794.77     23794.77   -492.55352   -492.55352 
   52000   -8405.5825   -8405.5825    -8483.147    -8483.147    300.18239    300.18239    23797.126    23797.126   -525.55488   -525.55488 
Loop time of 140.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.988 hours/ns, 7.125 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.11     | 140.11     | 140.11     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038035   | 0.038035   | 0.038035   |   0.0 |  0.03
Output  | 9.5163e-05 | 9.5163e-05 | 9.5163e-05 |   0.0 |  0.00
Modify  | 0.18162    | 0.18162    | 0.18162    |   0.0 |  0.13
Other   |            | 0.0288     |            |       |  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:      239332.0 ave      239332 max      239332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239332
Ave neighs/atom = 119.66600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.312339547374, Press = 1.45902923908605
next a
jump SELF top
variable a loop 2000
run 1000
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   -8405.5825   -8405.5825    -8483.147    -8483.147    300.18239    300.18239    23797.126    23797.126   -525.55488   -525.55488 
   53000   -8409.2262   -8409.2262   -8486.8568   -8486.8568    300.43851    300.43851    23805.639    23805.639   -1702.8331   -1702.8331 
Loop time of 142.21 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.96     | 141.96     | 141.96     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038253   | 0.038253   | 0.038253   |   0.0 |  0.03
Output  | 9.4327e-05 | 9.4327e-05 | 9.4327e-05 |   0.0 |  0.00
Modify  | 0.18344    | 0.18344    | 0.18344    |   0.0 |  0.13
Other   |            | 0.02896    |            |       |  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:      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 = 293.362674946012, Press = 0.610657922206357
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.2262   -8409.2262   -8486.8568   -8486.8568    300.43851    300.43851    23805.639    23805.639   -1702.8331   -1702.8331 
   54000   -8404.3902   -8404.3902   -8479.6356   -8479.6356    291.20734    291.20734    23807.545    23807.545   -921.88114   -921.88114 
Loop time of 153.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.564 ns/day, 42.539 hours/ns, 6.530 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.87     | 152.87     | 152.87     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041489   | 0.041489   | 0.041489   |   0.0 |  0.03
Output  | 0.00016161 | 0.00016161 | 0.00016161 |   0.0 |  0.00
Modify  | 0.19662    | 0.19662    | 0.19662    |   0.0 |  0.13
Other   |            | 0.03094    |            |       |  0.02

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

Total # of neighbors = 238908
Ave neighs/atom = 119.45400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.392356690024, Press = 0.00211510155688159
next a
jump SELF top
variable a loop 2000
run 1000
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   -8404.3902   -8404.3902   -8479.6356   -8479.6356    291.20734    291.20734    23807.545    23807.545   -921.88114   -921.88114 
   55000   -8409.4404   -8409.4404   -8485.3524   -8485.3524    293.78735    293.78735    23791.004    23791.004   -435.52325   -435.52325 
Loop time of 200.961 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.430 ns/day, 55.823 hours/ns, 4.976 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    | 200.61     | 200.61     | 200.61     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054666   | 0.054666   | 0.054666   |   0.0 |  0.03
Output  | 0.00025433 | 0.00025433 | 0.00025433 |   0.0 |  0.00
Modify  | 0.25565    | 0.25565    | 0.25565    |   0.0 |  0.13
Other   |            | 0.03984    |            |       |  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:      239144.0 ave      239144 max      239144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239144
Ave neighs/atom = 119.57200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.425338252759, Press = -0.126467727985516
next a
jump SELF top
variable a loop 2000
run 1000
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   -8409.4404   -8409.4404   -8485.3524   -8485.3524    293.78735    293.78735    23791.004    23791.004   -435.52325   -435.52325 
   56000   -8407.3019   -8407.3019   -8484.0568   -8484.0568    297.04944    297.04944    23785.042    23785.042    222.48699    222.48699 
Loop time of 170.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.451 hours/ns, 5.854 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.52     | 170.52     | 170.52     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046551   | 0.046551   | 0.046551   |   0.0 |  0.03
Output  | 0.00015374 | 0.00015374 | 0.00015374 |   0.0 |  0.00
Modify  | 0.22353    | 0.22353    | 0.22353    |   0.0 |  0.13
Other   |            | 0.03813    |            |       |  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:      239216.0 ave      239216 max      239216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239216
Ave neighs/atom = 119.60800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.429827535704, Press = 0.0185554732631994
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.3019   -8407.3019   -8484.0568   -8484.0568    297.04944    297.04944    23785.042    23785.042    222.48699    222.48699 
   57000   -8412.3272   -8412.3272    -8486.351    -8486.351    286.47978    286.47978     23772.48     23772.48    661.68565    661.68565 
Loop time of 218.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.396 ns/day, 60.644 hours/ns, 4.580 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    | 217.94     | 217.94     | 217.94     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05907    | 0.05907    | 0.05907    |   0.0 |  0.03
Output  | 0.00010024 | 0.00010024 | 0.00010024 |   0.0 |  0.00
Modify  | 0.27751    | 0.27751    | 0.27751    |   0.0 |  0.13
Other   |            | 0.04364    |            |       |  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:      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 = 293.388404248301, Press = 0.604045191298685
next a
jump SELF top
variable a loop 2000
run 1000
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   -8412.3272   -8412.3272    -8486.351    -8486.351    286.47978    286.47978     23772.48     23772.48    661.68565    661.68565 
   58000   -8406.0885   -8406.0885   -8481.5613   -8481.5613    292.08768    292.08768    23778.202    23778.202    975.93525    975.93525 
Loop time of 172.648 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 47.958 hours/ns, 5.792 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    | 172.34     | 172.34     | 172.34     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048852   | 0.048852   | 0.048852   |   0.0 |  0.03
Output  | 9.5429e-05 | 9.5429e-05 | 9.5429e-05 |   0.0 |  0.00
Modify  | 0.22547    | 0.22547    | 0.22547    |   0.0 |  0.13
Other   |            | 0.03691    |            |       |  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:      239508.0 ave      239508 max      239508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239508
Ave neighs/atom = 119.75400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.360172148464, Press = 0.995129536762829
next a
jump SELF top
variable a loop 2000
run 1000
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   -8406.0885   -8406.0885   -8481.5613   -8481.5613    292.08768    292.08768    23778.202    23778.202    975.93525    975.93525 
   59000   -8407.0389   -8407.0389   -8483.7537   -8483.7537    296.89438    296.89438    23779.676    23779.676     691.9355     691.9355 
Loop time of 146.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.590 ns/day, 40.668 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.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039143   | 0.039143   | 0.039143   |   0.0 |  0.03
Output  | 0.00017138 | 0.00017138 | 0.00017138 |   0.0 |  0.00
Modify  | 0.18923    | 0.18923    | 0.18923    |   0.0 |  0.13
Other   |            | 0.02992    |            |       |  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:      239550.0 ave      239550 max      239550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 239550
Ave neighs/atom = 119.77500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.366556751627, Press = 1.19540477105603
next a
jump SELF top
variable a loop 2000
run 1000
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   -8407.0389   -8407.0389   -8483.7537   -8483.7537    296.89438    296.89438    23779.676    23779.676     691.9355     691.9355 
   60000   -8406.3708   -8406.3708   -8483.5353   -8483.5353    298.63475    298.63475    23776.199    23776.199    882.70257    882.70257 
Loop time of 154.39 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.560 ns/day, 42.886 hours/ns, 6.477 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    | 154.12     | 154.12     | 154.12     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042005   | 0.042005   | 0.042005   |   0.0 |  0.03
Output  | 0.00012092 | 0.00012092 | 0.00012092 |   0.0 |  0.00
Modify  | 0.19882    | 0.19882    | 0.19882    |   0.0 |  0.13
Other   |            | 0.03225    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      239334.0 ave      239334 max      239334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.607 ns/day, 39.550 hours/ns, 7.023 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.13     | 142.13     | 142.13     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03808    | 0.03808    | 0.03808    |   0.0 |  0.03
Output  | 9.4014e-05 | 9.4014e-05 | 9.4014e-05 |   0.0 |  0.00
Modify  | 0.18338    | 0.18338    | 0.18338    |   0.0 |  0.13
Other   |            | 0.02935    |            |       |  0.02

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

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

Performance: 0.607 ns/day, 39.522 hours/ns, 7.029 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.03     | 142.03     | 142.03     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038045   | 0.038045   | 0.038045   |   0.0 |  0.03
Output  | 0.00010375 | 0.00010375 | 0.00010375 |   0.0 |  0.00
Modify  | 0.18303    | 0.18303    | 0.18303    |   0.0 |  0.13
Other   |            | 0.0294     |            |       |  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:      239692.0 ave      239692 max      239692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.602 ns/day, 39.861 hours/ns, 6.969 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    | 143.25     | 143.25     | 143.25     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038274   | 0.038274   | 0.038274   |   0.0 |  0.03
Output  | 9.4429e-05 | 9.4429e-05 | 9.4429e-05 |   0.0 |  0.00
Modify  | 0.18499    | 0.18499    | 0.18499    |   0.0 |  0.13
Other   |            | 0.02935    |            |       |  0.02

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

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

Performance: 0.604 ns/day, 39.757 hours/ns, 6.987 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.87     | 142.87     | 142.87     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038029   | 0.038029   | 0.038029   |   0.0 |  0.03
Output  | 9.7309e-05 | 9.7309e-05 | 9.7309e-05 |   0.0 |  0.00
Modify  | 0.18401    | 0.18401    | 0.18401    |   0.0 |  0.13
Other   |            | 0.02915    |            |       |  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:      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 = 293.454148242488, Press = 1.79612596650751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000    -8409.872    -8409.872   -8484.3436   -8484.3436    288.21294    288.21294    23791.126    23791.126   -354.16003   -354.16003 
   65000   -8405.0776   -8405.0776   -8482.2669   -8482.2669     298.7306     298.7306    23797.885    23797.885   -427.59865   -427.59865 
Loop time of 142.886 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.63     | 142.63     | 142.63     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038333   | 0.038333   | 0.038333   |   0.0 |  0.03
Output  | 9.1948e-05 | 9.1948e-05 | 9.1948e-05 |   0.0 |  0.00
Modify  | 0.18468    | 0.18468    | 0.18468    |   0.0 |  0.13
Other   |            | 0.0292     |            |       |  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:      239282.0 ave      239282 max      239282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.605 ns/day, 39.660 hours/ns, 7.004 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.53     | 142.53     | 142.53     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038629   | 0.038629   | 0.038629   |   0.0 |  0.03
Output  | 0.000101   | 0.000101   | 0.000101   |   0.0 |  0.00
Modify  | 0.18448    | 0.18448    | 0.18448    |   0.0 |  0.13
Other   |            | 0.0291     |            |       |  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:      239326.0 ave      239326 max      239326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.602 ns/day, 39.887 hours/ns, 6.964 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    | 143.34     | 143.34     | 143.34     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038376   | 0.038376   | 0.038376   |   0.0 |  0.03
Output  | 9.5931e-05 | 9.5931e-05 | 9.5931e-05 |   0.0 |  0.00
Modify  | 0.18458    | 0.18458    | 0.18458    |   0.0 |  0.13
Other   |            | 0.02941    |            |       |  0.02

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

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

Performance: 0.604 ns/day, 39.754 hours/ns, 6.987 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.86     | 142.86     | 142.86     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038232   | 0.038232   | 0.038232   |   0.0 |  0.03
Output  | 9.4423e-05 | 9.4423e-05 | 9.4423e-05 |   0.0 |  0.00
Modify  | 0.18501    | 0.18501    | 0.18501    |   0.0 |  0.13
Other   |            | 0.0294     |            |       |  0.02

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

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

Performance: 0.607 ns/day, 39.562 hours/ns, 7.021 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.17     | 142.17     | 142.17     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037972   | 0.037972   | 0.037972   |   0.0 |  0.03
Output  | 9.6555e-05 | 9.6555e-05 | 9.6555e-05 |   0.0 |  0.00
Modify  | 0.18431    | 0.18431    | 0.18431    |   0.0 |  0.13
Other   |            | 0.02925    |            |       |  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:      239028.0 ave      239028 max      239028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.606 ns/day, 39.585 hours/ns, 7.017 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.26     | 142.26     | 142.26     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.038001   | 0.038001   | 0.038001   |   0.0 |  0.03
Output  | 9.99e-05   | 9.99e-05   | 9.99e-05   |   0.0 |  0.00
Modify  | 0.1835     | 0.1835     | 0.1835     |   0.0 |  0.13
Other   |            | 0.02845    |            |       |  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:      238990.0 ave      238990 max      238990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.616 ns/day, 38.965 hours/ns, 7.129 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.03     | 140.03     | 140.03     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.037674   | 0.037674   | 0.037674   |   0.0 |  0.03
Output  | 8.9459e-05 | 8.9459e-05 | 8.9459e-05 |   0.0 |  0.00
Modify  | 0.18058    | 0.18058    | 0.18058    |   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:        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:      239250.0 ave      239250 max      239250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.533 ns/day, 45.040 hours/ns, 6.167 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    | 161.86     | 161.86     | 161.86     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04454    | 0.04454    | 0.04454    |   0.0 |  0.03
Output  | 9.4896e-05 | 9.4896e-05 | 9.4896e-05 |   0.0 |  0.00
Modify  | 0.20781    | 0.20781    | 0.20781    |   0.0 |  0.13
Other   |            | 0.03396    |            |       |  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:      239350.0 ave      239350 max      239350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.584 ns/day, 41.128 hours/ns, 6.754 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    | 147.8      | 147.8      | 147.8      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039937   | 0.039937   | 0.039937   |   0.0 |  0.03
Output  | 9.446e-05  | 9.446e-05  | 9.446e-05  |   0.0 |  0.00
Modify  | 0.19062    | 0.19062    | 0.19062    |   0.0 |  0.13
Other   |            | 0.03026    |            |       |  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:      239408.0 ave      239408 max      239408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.517 ns/day, 46.424 hours/ns, 5.983 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 166.83     | 166.83     | 166.83     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04566    | 0.04566    | 0.04566    |   0.0 |  0.03
Output  | 0.00036231 | 0.00036231 | 0.00036231 |   0.0 |  0.00
Modify  | 0.21505    | 0.21505    | 0.21505    |   0.0 |  0.13
Other   |            | 0.03396    |            |       |  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:      239644.0 ave      239644 max      239644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.543 ns/day, 44.228 hours/ns, 6.281 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    | 158.93     | 158.93     | 158.93     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044062   | 0.044062   | 0.044062   |   0.0 |  0.03
Output  | 0.00014927 | 0.00014927 | 0.00014927 |   0.0 |  0.00
Modify  | 0.20813    | 0.20813    | 0.20813    |   0.0 |  0.13
Other   |            | 0.03624    |            |       |  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:      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 = 293.424138120238, Press = 0.508913049745657
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8409.9118   -8409.9118   -8485.5185   -8485.5185    292.60603    292.60603    23738.007    23738.007    3235.9347    3235.9347 
   76000   -8406.0411   -8406.0411   -8483.0162   -8483.0162    297.90186    297.90186    23747.547    23747.547     2862.126     2862.126 
Loop time of 248.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.347 ns/day, 69.127 hours/ns, 4.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 248.44     | 248.44     | 248.44     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0665     | 0.0665     | 0.0665     |   0.0 |  0.03
Output  | 0.00015919 | 0.00015919 | 0.00015919 |   0.0 |  0.00
Modify  | 0.30433    | 0.30433    | 0.30433    |   0.0 |  0.12
Other   |            | 0.04611    |            |       |  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:      240112.0 ave      240112 max      240112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.387 ns/day, 61.955 hours/ns, 4.484 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    | 222.65     | 222.65     | 222.65     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060874   | 0.060874   | 0.060874   |   0.0 |  0.03
Output  | 0.00026164 | 0.00026164 | 0.00026164 |   0.0 |  0.00
Modify  | 0.28167    | 0.28167    | 0.28167    |   0.0 |  0.13
Other   |            | 0.04356    |            |       |  0.02

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4130.00 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      240044.0 ave      240044 max      240044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.403 ns/day, 59.610 hours/ns, 4.660 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 214.23     | 214.23     | 214.23     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057231   | 0.057231   | 0.057231   |   0.0 |  0.03
Output  | 9.375e-05  | 9.375e-05  | 9.375e-05  |   0.0 |  0.00
Modify  | 0.26891    | 0.26891    | 0.26891    |   0.0 |  0.13
Other   |            | 0.04273    |            |       |  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:      239796.0 ave      239796 max      239796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.463 ns/day, 51.871 hours/ns, 5.355 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    | 186.41     | 186.41     | 186.41     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050112   | 0.050112   | 0.050112   |   0.0 |  0.03
Output  | 0.00016178 | 0.00016178 | 0.00016178 |   0.0 |  0.00
Modify  | 0.23676    | 0.23676    | 0.23676    |   0.0 |  0.13
Other   |            | 0.03946    |            |       |  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:      239624.0 ave      239624 max      239624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.511 ns/day, 47.000 hours/ns, 5.910 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    | 168.9      | 168.9      | 168.9      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046304   | 0.046304   | 0.046304   |   0.0 |  0.03
Output  | 9.092e-05  | 9.092e-05  | 9.092e-05  |   0.0 |  0.00
Modify  | 0.214      | 0.214      | 0.214      |   0.0 |  0.13
Other   |            | 0.03736    |            |       |  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:      239504.0 ave      239504 max      239504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.515 ns/day, 46.638 hours/ns, 5.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 167.6      | 167.6      | 167.6      |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046587   | 0.046587   | 0.046587   |   0.0 |  0.03
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.21583    | 0.21583    | 0.21583    |   0.0 |  0.13
Other   |            | 0.0366     |            |       |  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:      239442.0 ave      239442 max      239442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.370 ns/day, 64.833 hours/ns, 4.284 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    | 233        | 233        | 233        |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.062334   | 0.062334   | 0.062334   |   0.0 |  0.03
Output  | 0.00015176 | 0.00015176 | 0.00015176 |   0.0 |  0.00
Modify  | 0.29203    | 0.29203    | 0.29203    |   0.0 |  0.13
Other   |            | 0.04597    |            |       |  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:      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 = 293.395194783253, Press = 2.08402487925247
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -8410.7692   -8410.7692   -8484.0727   -8484.0727    283.69197    283.69197    23792.801    23792.801    -538.9047    -538.9047 
   83000   -8409.3887   -8409.3887   -8486.1995   -8486.1995    297.26568    297.26568    23805.251    23805.251   -1596.4762   -1596.4762 
Loop time of 267.751 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.323 ns/day, 74.375 hours/ns, 3.735 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 267.3      | 267.3      | 267.3      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07055    | 0.07055    | 0.07055    |   0.0 |  0.03
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.33284    | 0.33284    | 0.33284    |   0.0 |  0.12
Other   |            | 0.0491     |            |       |  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:      239352.0 ave      239352 max      239352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.416 ns/day, 57.659 hours/ns, 4.818 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 207.21     | 207.21     | 207.21     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05658    | 0.05658    | 0.05658    |   0.0 |  0.03
Output  | 8.1215e-05 | 8.1215e-05 | 8.1215e-05 |   0.0 |  0.00
Modify  | 0.26465    | 0.26465    | 0.26465    |   0.0 |  0.13
Other   |            | 0.04261    |            |       |  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:      239058.0 ave      239058 max      239058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.406 ns/day, 59.041 hours/ns, 4.705 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    | 212.16     | 212.16     | 212.16     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058393   | 0.058393   | 0.058393   |   0.0 |  0.03
Output  | 0.00013473 | 0.00013473 | 0.00013473 |   0.0 |  0.00
Modify  | 0.28228    | 0.28228    | 0.28228    |   0.0 |  0.13
Other   |            | 0.04909    |            |       |  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:      239130.0 ave      239130 max      239130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.366 ns/day, 65.614 hours/ns, 4.234 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    | 235.8      | 235.8      | 235.8      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.063004   | 0.063004   | 0.063004   |   0.0 |  0.03
Output  | 0.00016581 | 0.00016581 | 0.00016581 |   0.0 |  0.00
Modify  | 0.29818    | 0.29818    | 0.29818    |   0.0 |  0.13
Other   |            | 0.04697    |            |       |  0.02

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

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

Performance: 0.412 ns/day, 58.313 hours/ns, 4.764 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    | 209.55     | 209.55     | 209.55     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057756   | 0.057756   | 0.057756   |   0.0 |  0.03
Output  | 0.00021888 | 0.00021888 | 0.00021888 |   0.0 |  0.00
Modify  | 0.27022    | 0.27022    | 0.27022    |   0.0 |  0.13
Other   |            | 0.04462    |            |       |  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:      238862.0 ave      238862 max      238862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.539 ns/day, 44.486 hours/ns, 6.244 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.86     | 159.86     | 159.86     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04377    | 0.04377    | 0.04377    |   0.0 |  0.03
Output  | 0.00013418 | 0.00013418 | 0.00013418 |   0.0 |  0.00
Modify  | 0.20879    | 0.20879    | 0.20879    |   0.0 |  0.13
Other   |            | 0.03438    |            |       |  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:      238922.0 ave      238922 max      238922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.629 ns/day, 38.163 hours/ns, 7.279 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.14     | 137.14     | 137.14     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036964   | 0.036964   | 0.036964   |   0.0 |  0.03
Output  | 9.4623e-05 | 9.4623e-05 | 9.4623e-05 |   0.0 |  0.00
Modify  | 0.1758     | 0.1758     | 0.1758     |   0.0 |  0.13
Other   |            | 0.02991    |            |       |  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:      238968.0 ave      238968 max      238968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.549 ns/day, 43.755 hours/ns, 6.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 157.23     | 157.23     | 157.23     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042391   | 0.042391   | 0.042391   |   0.0 |  0.03
Output  | 9.5961e-05 | 9.5961e-05 | 9.5961e-05 |   0.0 |  0.00
Modify  | 0.21506    | 0.21506    | 0.21506    |   0.0 |  0.14
Other   |            | 0.03263    |            |       |  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:      239368.0 ave      239368 max      239368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.99     | 148.99     | 148.99     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040232   | 0.040232   | 0.040232   |   0.0 |  0.03
Output  | 0.00032219 | 0.00032219 | 0.00032219 |   0.0 |  0.00
Modify  | 0.19311    | 0.19311    | 0.19311    |   0.0 |  0.13
Other   |            | 0.03106    |            |       |  0.02

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0