# 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 3.889087237417698*${_u_distance}
variable latticeconst_converted equal 3.889087237417698*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.8890872374177
Lattice spacing in x,y,z = 3.8890872 3.8890872 3.8890872
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 (38.890872 38.890872 38.890872)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (38.890872 38.890872 38.890872)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoLee_2013_VPdY__MO_046547823135_001
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 58822.4426779163 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_046547823135_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -15478.129   -15478.129       -15640       -15640       313.15       313.15    58822.443    58822.443    2939.3412    2939.3412 
    1000   -15319.199   -15319.199   -15481.387   -15481.387    313.76236    313.76236    59577.918    59577.918    244.13252    244.13252 
Loop time of 415.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.444 hours/ns, 2.406 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    | 414.57     | 414.57     | 414.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20476    | 0.20476    | 0.20476    |   0.0 |  0.05
Output  | 0.00026489 | 0.00026489 | 0.00026489 |   0.0 |  0.00
Modify  | 0.71854    | 0.71854    | 0.71854    |   0.0 |  0.17
Other   |            | 0.1025     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -15319.199   -15319.199   -15481.387   -15481.387    313.76236    313.76236    59577.918    59577.918    244.13252    244.13252 
    2000    -15321.26    -15321.26    -15478.43    -15478.43    304.05603    304.05603    59500.283    59500.283    3015.0072    3015.0072 
Loop time of 395.432 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.842 hours/ns, 2.529 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    | 394.5      | 394.5      | 394.5      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19305    | 0.19305    | 0.19305    |   0.0 |  0.05
Output  | 0.00025067 | 0.00025067 | 0.00025067 |   0.0 |  0.00
Modify  | 0.64361    | 0.64361    | 0.64361    |   0.0 |  0.16
Other   |            | 0.0987     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559390.0 ave      559390 max      559390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559390
Ave neighs/atom = 139.84750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -15321.26    -15321.26    -15478.43    -15478.43    304.05603    304.05603    59500.283    59500.283    3015.0072    3015.0072 
    3000   -15328.468   -15328.468   -15484.222   -15484.222    301.31774    301.31774    59592.628    59592.628   -559.83471   -559.83471 
Loop time of 423.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.631 hours/ns, 2.361 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    | 422.46     | 422.46     | 422.46     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2033     | 0.2033     | 0.2033     |   0.0 |  0.05
Output  | 0.00021995 | 0.00021995 | 0.00021995 |   0.0 |  0.00
Modify  | 0.70946    | 0.70946    | 0.70946    |   0.0 |  0.17
Other   |            | 0.1025     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8176.00 ave        8176 max        8176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559640.0 ave      559640 max      559640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559640
Ave neighs/atom = 139.91000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -15328.468   -15328.468   -15484.222   -15484.222    301.31774    301.31774    59592.628    59592.628   -559.83471   -559.83471 
    4000   -15318.211   -15318.211   -15485.893   -15485.893    324.39072    324.39072     59609.51     59609.51   -970.90617   -970.90617 
Loop time of 466.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.473 hours/ns, 2.145 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    | 464.96     | 464.96     | 464.96     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22024    | 0.22024    | 0.22024    |   0.0 |  0.05
Output  | 0.00026701 | 0.00026701 | 0.00026701 |   0.0 |  0.00
Modify  | 0.81035    | 0.81035    | 0.81035    |   0.0 |  0.17
Other   |            | 0.1096     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559478.0 ave      559478 max      559478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559478
Ave neighs/atom = 139.86950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -15318.211   -15318.211   -15485.893   -15485.893    324.39072    324.39072     59609.51     59609.51   -970.90617   -970.90617 
    5000   -15325.015   -15325.015   -15483.769   -15483.769    307.12014    307.12014    59508.709    59508.709    2181.2224    2181.2224 
Loop time of 404.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.243 hours/ns, 2.475 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    | 403.11     | 403.11     | 403.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19797    | 0.19797    | 0.19797    |   0.0 |  0.05
Output  | 0.00018196 | 0.00018196 | 0.00018196 |   0.0 |  0.00
Modify  | 0.66634    | 0.66634    | 0.66634    |   0.0 |  0.16
Other   |            | 0.09842    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559490.0 ave      559490 max      559490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559490
Ave neighs/atom = 139.87250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.782074354587, Press = -655.602890027983
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -15325.015   -15325.015   -15483.769   -15483.769    307.12014    307.12014    59508.709    59508.709    2181.2224    2181.2224 
    6000   -15322.423   -15322.423   -15482.872   -15482.872    310.39989    310.39989    59580.694    59580.694   -134.90951   -134.90951 
Loop time of 461.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.073 hours/ns, 2.169 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    | 459.92     | 459.92     | 459.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2188     | 0.2188     | 0.2188     |   0.0 |  0.05
Output  | 0.00028632 | 0.00028632 | 0.00028632 |   0.0 |  0.00
Modify  | 0.81888    | 0.81888    | 0.81888    |   0.0 |  0.18
Other   |            | 0.1097     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559590.0 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.89750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.467367050451, Press = -46.4923176804072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -15322.423   -15322.423   -15482.872   -15482.872    310.39989    310.39989    59580.694    59580.694   -134.90951   -134.90951 
    7000   -15322.543   -15322.543    -15485.55    -15485.55    315.34735    315.34735    59573.383    59573.383     64.56288     64.56288 
Loop time of 458.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.229 hours/ns, 2.183 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    | 456.89     | 456.89     | 456.89     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2163     | 0.2163     | 0.2163     |   0.0 |  0.05
Output  | 0.00022897 | 0.00022897 | 0.00022897 |   0.0 |  0.00
Modify  | 0.81225    | 0.81225    | 0.81225    |   0.0 |  0.18
Other   |            | 0.1091     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559576.0 ave      559576 max      559576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559576
Ave neighs/atom = 139.89400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.013036929617, Press = -17.4014353389644
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -15322.543   -15322.543    -15485.55    -15485.55    315.34735    315.34735    59573.383    59573.383     64.56288     64.56288 
    8000   -15323.933   -15323.933   -15487.653   -15487.653    316.72745    316.72745     59580.93     59580.93   -411.84174   -411.84174 
Loop time of 428.142 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.928 hours/ns, 2.336 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    | 427.1      | 427.1      | 427.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20414    | 0.20414    | 0.20414    |   0.0 |  0.05
Output  | 0.00021461 | 0.00021461 | 0.00021461 |   0.0 |  0.00
Modify  | 0.7341     | 0.7341     | 0.7341     |   0.0 |  0.17
Other   |            | 0.1021     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8173.00 ave        8173 max        8173 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559474.0 ave      559474 max      559474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559474
Ave neighs/atom = 139.86850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.307003749965, Press = -14.688941973016
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -15323.933   -15323.933   -15487.653   -15487.653    316.72745    316.72745     59580.93     59580.93   -411.84174   -411.84174 
    9000   -15318.741   -15318.741   -15483.637   -15483.637    319.00154    319.00154      59579.8      59579.8    124.15312    124.15312 
Loop time of 441.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.746 hours/ns, 2.263 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 440.78     | 440.78     | 440.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21312    | 0.21312    | 0.21312    |   0.0 |  0.05
Output  | 0.00024813 | 0.00024813 | 0.00024813 |   0.0 |  0.00
Modify  | 0.78781    | 0.78781    | 0.78781    |   0.0 |  0.18
Other   |            | 0.1073     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8177.00 ave        8177 max        8177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559514.0 ave      559514 max      559514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559514
Ave neighs/atom = 139.87850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.520874631624, Press = -14.8744875553513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -15318.741   -15318.741   -15483.637   -15483.637    319.00154    319.00154      59579.8      59579.8    124.15312    124.15312 
   10000   -15323.127   -15323.127   -15484.941   -15484.941    313.04135    313.04135    59539.178    59539.178    1105.3734    1105.3734 
Loop time of 408.379 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.439 hours/ns, 2.449 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    | 407.38     | 407.38     | 407.38     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19914    | 0.19914    | 0.19914    |   0.0 |  0.05
Output  | 0.00018318 | 0.00018318 | 0.00018318 |   0.0 |  0.00
Modify  | 0.69804    | 0.69804    | 0.69804    |   0.0 |  0.17
Other   |            | 0.09933    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559532.0 ave      559532 max      559532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559532
Ave neighs/atom = 139.88300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.553167550414, Press = -9.33490956680966
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -15323.127   -15323.127   -15484.941   -15484.941    313.04135    313.04135    59539.178    59539.178    1105.3734    1105.3734 
   11000   -15320.768   -15320.768   -15482.965   -15482.965    313.78233    313.78233    59606.707    59606.707   -643.13444   -643.13444 
Loop time of 411.276 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.243 hours/ns, 2.431 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    | 410.27     | 410.27     | 410.27     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20249    | 0.20249    | 0.20249    |   0.0 |  0.05
Output  | 0.00022645 | 0.00022645 | 0.00022645 |   0.0 |  0.00
Modify  | 0.70482    | 0.70482    | 0.70482    |   0.0 |  0.17
Other   |            | 0.09906    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559588.0 ave      559588 max      559588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559588
Ave neighs/atom = 139.89700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.990192221428, Press = -14.0936451927098
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -15320.768   -15320.768   -15482.965   -15482.965    313.78233    313.78233    59606.707    59606.707   -643.13444   -643.13444 
   12000   -15324.517   -15324.517   -15483.264   -15483.264    307.10694    307.10694    59635.379    59635.379     -1836.02     -1836.02 
Loop time of 442.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.873 hours/ns, 2.261 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    | 441.24     | 441.24     | 441.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21339    | 0.21339    | 0.21339    |   0.0 |  0.05
Output  | 0.00022546 | 0.00022546 | 0.00022546 |   0.0 |  0.00
Modify  | 0.78438    | 0.78438    | 0.78438    |   0.0 |  0.18
Other   |            | 0.1061     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559344.0 ave      559344 max      559344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559344
Ave neighs/atom = 139.83600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.971071850934, Press = -10.676296936048
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -15324.517   -15324.517   -15483.264   -15483.264    307.10694    307.10694    59635.379    59635.379     -1836.02     -1836.02 
   13000   -15323.359   -15323.359   -15481.902   -15481.902    306.71257    306.71257     59610.62     59610.62   -762.63042   -762.63042 
Loop time of 467.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.785 hours/ns, 2.140 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    | 466.07     | 466.07     | 466.07     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21793    | 0.21793    | 0.21793    |   0.0 |  0.05
Output  | 0.00018177 | 0.00018177 | 0.00018177 |   0.0 |  0.00
Modify  | 0.8264     | 0.8264     | 0.8264     |   0.0 |  0.18
Other   |            | 0.1107     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559432.0 ave      559432 max      559432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559432
Ave neighs/atom = 139.85800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.012426465953, Press = -5.91123352035549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -15323.359   -15323.359   -15481.902   -15481.902    306.71257    306.71257     59610.62     59610.62   -762.63042   -762.63042 
   14000    -15315.76    -15315.76   -15480.202   -15480.202    318.12417    318.12417    59656.693    59656.693   -2035.9742   -2035.9742 
Loop time of 454.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.260 hours/ns, 2.200 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    | 453.42     | 453.42     | 453.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21451    | 0.21451    | 0.21451    |   0.0 |  0.05
Output  | 0.00018154 | 0.00018154 | 0.00018154 |   0.0 |  0.00
Modify  | 0.79838    | 0.79838    | 0.79838    |   0.0 |  0.18
Other   |            | 0.1075     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559372.0 ave      559372 max      559372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559372
Ave neighs/atom = 139.84300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.02590286432, Press = -3.19607217997397
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -15315.76    -15315.76   -15480.202   -15480.202    318.12417    318.12417    59656.693    59656.693   -2035.9742   -2035.9742 
   15000    -15325.39    -15325.39   -15486.431   -15486.431    311.54469    311.54469     59594.93     59594.93   -689.82181   -689.82181 
Loop time of 457.793 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.165 hours/ns, 2.184 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    | 456.65     | 456.65     | 456.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21764    | 0.21764    | 0.21764    |   0.0 |  0.05
Output  | 0.00028262 | 0.00028262 | 0.00028262 |   0.0 |  0.00
Modify  | 0.81763    | 0.81763    | 0.81763    |   0.0 |  0.18
Other   |            | 0.1117     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559392.0 ave      559392 max      559392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559392
Ave neighs/atom = 139.84800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.127579940163, Press = -0.437348178725414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -15325.39    -15325.39   -15486.431   -15486.431    311.54469    311.54469     59594.93     59594.93   -689.82181   -689.82181 
   16000   -15325.424   -15325.424   -15484.563   -15484.563    307.86496    307.86496     59582.76     59582.76    -219.0535    -219.0535 
Loop time of 404.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.304 hours/ns, 2.473 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    | 403.3      | 403.3      | 403.3      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19761    | 0.19761    | 0.19761    |   0.0 |  0.05
Output  | 0.00019498 | 0.00019498 | 0.00019498 |   0.0 |  0.00
Modify  | 0.69456    | 0.69456    | 0.69456    |   0.0 |  0.17
Other   |            | 0.1026     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559472.0 ave      559472 max      559472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559472
Ave neighs/atom = 139.86800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.003744952822, Press = -0.811121720091189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -15325.424   -15325.424   -15484.563   -15484.563    307.86496    307.86496     59582.76     59582.76    -219.0535    -219.0535 
   17000   -15321.138   -15321.138   -15487.191   -15487.191     321.2396     321.2396    59547.277    59547.277    634.56989    634.56989 
Loop time of 441.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.619 hours/ns, 2.265 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    | 440.34     | 440.34     | 440.34     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21029    | 0.21029    | 0.21029    |   0.0 |  0.05
Output  | 0.00018119 | 0.00018119 | 0.00018119 |   0.0 |  0.00
Modify  | 0.77278    | 0.77278    | 0.77278    |   0.0 |  0.18
Other   |            | 0.106      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559512.0 ave      559512 max      559512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559512
Ave neighs/atom = 139.87800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.757513321393, Press = -1.60255464623795
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -15321.138   -15321.138   -15487.191   -15487.191     321.2396     321.2396    59547.277    59547.277    634.56989    634.56989 
   18000   -15323.066   -15323.066   -15483.603   -15483.603       310.57       310.57    59542.842    59542.842    1091.4887    1091.4887 
Loop time of 439.844 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.179 hours/ns, 2.274 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    | 438.76     | 438.76     | 438.76     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20959    | 0.20959    | 0.20959    |   0.0 |  0.05
Output  | 0.00018259 | 0.00018259 | 0.00018259 |   0.0 |  0.00
Modify  | 0.77304    | 0.77304    | 0.77304    |   0.0 |  0.18
Other   |            | 0.1056     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559560.0 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.67009968667, Press = -3.65811782338085
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -15323.066   -15323.066   -15483.603   -15483.603       310.57       310.57    59542.842    59542.842    1091.4887    1091.4887 
   19000   -15324.553   -15324.553   -15488.146   -15488.146    316.48184    316.48184    59546.993    59546.993    622.81466    622.81466 
Loop time of 460.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.959 hours/ns, 2.171 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    | 459.51     | 459.51     | 459.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21732    | 0.21732    | 0.21732    |   0.0 |  0.05
Output  | 0.00018312 | 0.00018312 | 0.00018312 |   0.0 |  0.00
Modify  | 0.81575    | 0.81575    | 0.81575    |   0.0 |  0.18
Other   |            | 0.1101     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559530.0 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.88250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.680203768982, Press = -5.57872787094732
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -15324.553   -15324.553   -15488.146   -15488.146    316.48184    316.48184    59546.993    59546.993    622.81466    622.81466 
   20000   -15324.271   -15324.271   -15486.189   -15486.189    313.24203    313.24203    59580.676    59580.676   -138.57491   -138.57491 
Loop time of 464.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.103 hours/ns, 2.152 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    | 463.6      | 463.6      | 463.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22148    | 0.22148    | 0.22148    |   0.0 |  0.05
Output  | 0.00023396 | 0.00023396 | 0.00023396 |   0.0 |  0.00
Modify  | 0.83315    | 0.83315    | 0.83315    |   0.0 |  0.18
Other   |            | 0.1117     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559600.0 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.613569912241, Press = -5.03787487774343
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -15324.271   -15324.271   -15486.189   -15486.189    313.24203    313.24203    59580.676    59580.676   -138.57491   -138.57491 
   21000    -15323.97    -15323.97   -15485.225   -15485.225    311.95877    311.95877    59569.784    59569.784    191.66363    191.66363 
Loop time of 459.564 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.657 hours/ns, 2.176 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    | 458.43     | 458.43     | 458.43     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2162     | 0.2162     | 0.2162     |   0.0 |  0.05
Output  | 0.00018126 | 0.00018126 | 0.00018126 |   0.0 |  0.00
Modify  | 0.80169    | 0.80169    | 0.80169    |   0.0 |  0.17
Other   |            | 0.1106     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559514.0 ave      559514 max      559514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559514
Ave neighs/atom = 139.87850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.455286949362, Press = -4.93527278361459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000    -15323.97    -15323.97   -15485.225   -15485.225    311.95877    311.95877    59569.784    59569.784    191.66363    191.66363 
   22000   -15323.321   -15323.321   -15484.093   -15484.093    311.02383    311.02383    59605.995    59605.995    -745.5107    -745.5107 
Loop time of 465.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.396 hours/ns, 2.147 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.67     | 464.67     | 464.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21913    | 0.21913    | 0.21913    |   0.0 |  0.05
Output  | 0.00022925 | 0.00022925 | 0.00022925 |   0.0 |  0.00
Modify  | 0.82874    | 0.82874    | 0.82874    |   0.0 |  0.18
Other   |            | 0.1113     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559530.0 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.88250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.387692397531, Press = -5.87760199997056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -15323.321   -15323.321   -15484.093   -15484.093    311.02383    311.02383    59605.995    59605.995    -745.5107    -745.5107 
   23000   -15315.221   -15315.221   -15483.159   -15483.159    324.88814    324.88814    59645.204    59645.204   -1854.3252   -1854.3252 
Loop time of 465.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.402 hours/ns, 2.147 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 464.68     | 464.68     | 464.68     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21936    | 0.21936    | 0.21936    |   0.0 |  0.05
Output  | 0.00018345 | 0.00018345 | 0.00018345 |   0.0 |  0.00
Modify  | 0.83725    | 0.83725    | 0.83725    |   0.0 |  0.18
Other   |            | 0.1122     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559426.0 ave      559426 max      559426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559426
Ave neighs/atom = 139.85650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.374685535793, Press = -4.75810582407347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -15315.221   -15315.221   -15483.159   -15483.159    324.88814    324.88814    59645.204    59645.204   -1854.3252   -1854.3252 
   24000   -15322.097   -15322.097   -15483.645   -15483.645    312.52532    312.52532    59633.336    59633.336   -1546.7099   -1546.7099 
Loop time of 466.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.539 hours/ns, 2.144 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    | 465.17     | 465.17     | 465.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22072    | 0.22072    | 0.22072    |   0.0 |  0.05
Output  | 0.0002378  | 0.0002378  | 0.0002378  |   0.0 |  0.00
Modify  | 0.84082    | 0.84082    | 0.84082    |   0.0 |  0.18
Other   |            | 0.1128     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8171.00 ave        8171 max        8171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559454.0 ave      559454 max      559454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559454
Ave neighs/atom = 139.86350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378716370914, Press = -3.35272105918845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -15322.097   -15322.097   -15483.645   -15483.645    312.52532    312.52532    59633.336    59633.336   -1546.7099   -1546.7099 
   25000   -15326.533   -15326.533   -15487.726   -15487.726     311.8375     311.8375    59616.749    59616.749   -1547.0373   -1547.0373 
Loop time of 465.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.344 hours/ns, 2.148 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    | 464.48     | 464.48     | 464.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21866    | 0.21866    | 0.21866    |   0.0 |  0.05
Output  | 0.0001803  | 0.0001803  | 0.0001803  |   0.0 |  0.00
Modify  | 0.82358    | 0.82358    | 0.82358    |   0.0 |  0.18
Other   |            | 0.111      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559400.0 ave      559400 max      559400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559400
Ave neighs/atom = 139.85000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.350186299096, Press = -2.88087433478027
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -15326.533   -15326.533   -15487.726   -15487.726     311.8375     311.8375    59616.749    59616.749   -1547.0373   -1547.0373 
   26000   -15324.074   -15324.074   -15484.048   -15484.048    309.48154    309.48154    59629.995    59629.995   -1596.2595   -1596.2595 
Loop time of 453.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.067 hours/ns, 2.203 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    | 452.71     | 452.71     | 452.71     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21583    | 0.21583    | 0.21583    |   0.0 |  0.05
Output  | 0.00018027 | 0.00018027 | 0.00018027 |   0.0 |  0.00
Modify  | 0.8075     | 0.8075     | 0.8075     |   0.0 |  0.18
Other   |            | 0.1095     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8179.00 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559544.0 ave      559544 max      559544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559544
Ave neighs/atom = 139.88600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.227031096916, Press = -2.34326554642074
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -15324.074   -15324.074   -15484.048   -15484.048    309.48154    309.48154    59629.995    59629.995   -1596.2595   -1596.2595 
   27000   -15324.084   -15324.084   -15484.677   -15484.677    310.67939    310.67939    59602.493    59602.493   -708.47398   -708.47398 
Loop time of 468.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.184 ns/day, 130.270 hours/ns, 2.132 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    | 467.79     | 467.79     | 467.79     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22468    | 0.22468    | 0.22468    |   0.0 |  0.05
Output  | 0.00018356 | 0.00018356 | 0.00018356 |   0.0 |  0.00
Modify  | 0.84631    | 0.84631    | 0.84631    |   0.0 |  0.18
Other   |            | 0.1125     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8186.00 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559484.0 ave      559484 max      559484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559484
Ave neighs/atom = 139.87100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.208317606474, Press = -1.60884647018571
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -15324.084   -15324.084   -15484.677   -15484.677    310.67939    310.67939    59602.493    59602.493   -708.47398   -708.47398 
   28000   -15322.182   -15322.182   -15484.797   -15484.797    314.58994    314.58994    59593.582    59593.582   -531.54681   -531.54681 
Loop time of 458.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.434 hours/ns, 2.180 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    | 457.62     | 457.62     | 457.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21733    | 0.21733    | 0.21733    |   0.0 |  0.05
Output  | 0.00025266 | 0.00025266 | 0.00025266 |   0.0 |  0.00
Modify  | 0.80907    | 0.80907    | 0.80907    |   0.0 |  0.18
Other   |            | 0.1104     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559494.0 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.87350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.233519985094, Press = -0.707192852813919
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -15322.182   -15322.182   -15484.797   -15484.797    314.58994    314.58994    59593.582    59593.582   -531.54681   -531.54681 
   29000   -15321.436   -15321.436   -15484.167   -15484.167     314.8139     314.8139    59554.746    59554.746    838.03858    838.03858 
Loop time of 412.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.638 hours/ns, 2.423 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    | 411.67     | 411.67     | 411.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20368    | 0.20368    | 0.20368    |   0.0 |  0.05
Output  | 0.00018046 | 0.00018046 | 0.00018046 |   0.0 |  0.00
Modify  | 0.71723    | 0.71723    | 0.71723    |   0.0 |  0.17
Other   |            | 0.1017     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559492.0 ave      559492 max      559492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559492
Ave neighs/atom = 139.87300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.226360715808, Press = -0.93848810392924
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -15321.436   -15321.436   -15484.167   -15484.167     314.8139     314.8139    59554.746    59554.746    838.03858    838.03858 
   30000   -15323.011   -15323.011   -15485.854   -15485.854    315.03202    315.03202    59561.481    59561.481    334.14494    334.14494 
Loop time of 427.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.767 hours/ns, 2.339 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    | 426.51     | 426.51     | 426.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20783    | 0.20783    | 0.20783    |   0.0 |  0.05
Output  | 0.0001807  | 0.0001807  | 0.0001807  |   0.0 |  0.00
Modify  | 0.73959    | 0.73959    | 0.73959    |   0.0 |  0.17
Other   |            | 0.1035     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559478.0 ave      559478 max      559478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559478
Ave neighs/atom = 139.86950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.305002294913, Press = -1.99038568561116
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -15323.011   -15323.011   -15485.854   -15485.854    315.03202    315.03202    59561.481    59561.481    334.14494    334.14494 
   31000    -15321.14    -15321.14   -15482.029   -15482.029    311.25189    311.25189    59547.676    59547.676    1318.5183    1318.5183 
Loop time of 430.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.579 hours/ns, 2.323 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    | 429.43     | 429.43     | 429.43     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20931    | 0.20931    | 0.20931    |   0.0 |  0.05
Output  | 0.00028945 | 0.00028945 | 0.00028945 |   0.0 |  0.00
Modify  | 0.74432    | 0.74432    | 0.74432    |   0.0 |  0.17
Other   |            | 0.1039     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559578.0 ave      559578 max      559578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559578
Ave neighs/atom = 139.89450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.351642094507, Press = -1.33444038499724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -15321.14    -15321.14   -15482.029   -15482.029    311.25189    311.25189    59547.676    59547.676    1318.5183    1318.5183 
   32000   -15322.787   -15322.787   -15485.651   -15485.651    315.07116    315.07116    59581.846    59581.846   -156.29783   -156.29783 
Loop time of 406.514 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.920 hours/ns, 2.460 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    | 405.51     | 405.51     | 405.51     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2021     | 0.2021     | 0.2021     |   0.0 |  0.05
Output  | 0.00018383 | 0.00018383 | 0.00018383 |   0.0 |  0.00
Modify  | 0.69715    | 0.69715    | 0.69715    |   0.0 |  0.17
Other   |            | 0.1007     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8171.00 ave        8171 max        8171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559520.0 ave      559520 max      559520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559520
Ave neighs/atom = 139.88000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.423189175139, Press = -1.60020662232555
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -15322.787   -15322.787   -15485.651   -15485.651    315.07116    315.07116    59581.846    59581.846   -156.29783   -156.29783 
   33000   -15320.494   -15320.494   -15484.502   -15484.502    317.28439    317.28439    59561.093    59561.093    508.06476    508.06476 
Loop time of 395.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.816 hours/ns, 2.529 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    | 394.37     | 394.37     | 394.37     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19782    | 0.19782    | 0.19782    |   0.0 |  0.05
Output  | 0.00018194 | 0.00018194 | 0.00018194 |   0.0 |  0.00
Modify  | 0.67286    | 0.67286    | 0.67286    |   0.0 |  0.17
Other   |            | 0.09815    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559506.0 ave      559506 max      559506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559506
Ave neighs/atom = 139.87650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.433152099744, Press = -1.73089804462111
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -15320.494   -15320.494   -15484.502   -15484.502    317.28439    317.28439    59561.093    59561.093    508.06476    508.06476 
   34000   -15327.081   -15327.081   -15488.437   -15488.437    312.15378    312.15378    59538.395    59538.395    750.15279    750.15279 
Loop time of 395.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.896 hours/ns, 2.528 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    | 394.66     | 394.66     | 394.66     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19947    | 0.19947    | 0.19947    |   0.0 |  0.05
Output  | 0.00018577 | 0.00018577 | 0.00018577 |   0.0 |  0.00
Modify  | 0.67348    | 0.67348    | 0.67348    |   0.0 |  0.17
Other   |            | 0.09808    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559528.0 ave      559528 max      559528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559528
Ave neighs/atom = 139.88200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.486378664427, Press = -2.22782854351899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -15327.081   -15327.081   -15488.437   -15488.437    312.15378    312.15378    59538.395    59538.395    750.15279    750.15279 
   35000   -15322.137   -15322.137   -15484.118   -15484.118    313.36334    313.36334    59535.428    59535.428    1383.3266    1383.3266 
Loop time of 395.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.769 hours/ns, 2.531 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    | 394.2      | 394.2      | 394.2      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19797    | 0.19797    | 0.19797    |   0.0 |  0.05
Output  | 0.00018177 | 0.00018177 | 0.00018177 |   0.0 |  0.00
Modify  | 0.67039    | 0.67039    | 0.67039    |   0.0 |  0.17
Other   |            | 0.09797    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8186.00 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559636.0 ave      559636 max      559636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559636
Ave neighs/atom = 139.90900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.438963867538, Press = -1.90459650227749
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -15322.137   -15322.137   -15484.118   -15484.118    313.36334    313.36334    59535.428    59535.428    1383.3266    1383.3266 
   36000   -15325.276   -15325.276   -15487.309   -15487.309    313.46364    313.46364    59522.787    59522.787    1475.6361    1475.6361 
Loop time of 408.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.465 hours/ns, 2.448 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    | 407.47     | 407.47     | 407.47     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20391    | 0.20391    | 0.20391    |   0.0 |  0.05
Output  | 0.00025618 | 0.00025618 | 0.00025618 |   0.0 |  0.00
Modify  | 0.7023     | 0.7023     | 0.7023     |   0.0 |  0.17
Other   |            | 0.1003     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559624.0 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.90600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363697721782, Press = -3.16342999737355
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -15325.276   -15325.276   -15487.309   -15487.309    313.46364    313.46364    59522.787    59522.787    1475.6361    1475.6361 
   37000   -15321.728   -15321.728   -15485.037   -15485.037    315.93264    315.93264    59550.155    59550.155    855.54781    855.54781 
Loop time of 466.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.616 hours/ns, 2.143 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    | 465.46     | 465.46     | 465.46     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21988    | 0.21988    | 0.21988    |   0.0 |  0.05
Output  | 0.00018237 | 0.00018237 | 0.00018237 |   0.0 |  0.00
Modify  | 0.82408    | 0.82408    | 0.82408    |   0.0 |  0.18
Other   |            | 0.1102     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8179.00 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559582.0 ave      559582 max      559582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559582
Ave neighs/atom = 139.89550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.364019753974, Press = -2.81435457882328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -15321.728   -15321.728   -15485.037   -15485.037    315.93264    315.93264    59550.155    59550.155    855.54781    855.54781 
   38000    -15321.78    -15321.78   -15484.135   -15484.135    314.08653    314.08653    59576.174    59576.174    194.00115    194.00115 
Loop time of 462.769 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.547 hours/ns, 2.161 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    | 461.62     | 461.62     | 461.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21983    | 0.21983    | 0.21983    |   0.0 |  0.05
Output  | 0.00018183 | 0.00018183 | 0.00018183 |   0.0 |  0.00
Modify  | 0.81501    | 0.81501    | 0.81501    |   0.0 |  0.18
Other   |            | 0.1094     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8186.00 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559584.0 ave      559584 max      559584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559584
Ave neighs/atom = 139.89600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.316839893069, Press = -2.00429378623331
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -15321.78    -15321.78   -15484.135   -15484.135    314.08653    314.08653    59576.174    59576.174    194.00115    194.00115 
   39000   -15329.896   -15329.896   -15487.348   -15487.348    304.60188    304.60188    59575.997    59575.997    -325.8269    -325.8269 
Loop time of 465.064 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.186 ns/day, 129.185 hours/ns, 2.150 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    | 463.91     | 463.91     | 463.91     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22046    | 0.22046    | 0.22046    |   0.0 |  0.05
Output  | 0.00023064 | 0.00023064 | 0.00023064 |   0.0 |  0.00
Modify  | 0.82661    | 0.82661    | 0.82661    |   0.0 |  0.18
Other   |            | 0.1096     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559544.0 ave      559544 max      559544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559544
Ave neighs/atom = 139.88600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.297753437059, Press = -1.94582666444937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -15329.896   -15329.896   -15487.348   -15487.348    304.60188    304.60188    59575.997    59575.997    -325.8269    -325.8269 
   40000   -15320.548   -15320.548   -15488.024   -15488.024    323.99396    323.99396    59612.643    59612.643   -1421.4408   -1421.4408 
Loop time of 445.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.713 hours/ns, 2.245 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    | 444.25     | 444.25     | 444.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21437    | 0.21437    | 0.21437    |   0.0 |  0.05
Output  | 0.00018311 | 0.00018311 | 0.00018311 |   0.0 |  0.00
Modify  | 0.79351    | 0.79351    | 0.79351    |   0.0 |  0.18
Other   |            | 0.1083     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8176.00 ave        8176 max        8176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559508.0 ave      559508 max      559508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559508
Ave neighs/atom = 139.87700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.250840888888, Press = -1.10397371263743
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -15320.548   -15320.548   -15488.024   -15488.024    323.99396    323.99396    59612.643    59612.643   -1421.4408   -1421.4408 
   41000    -15328.46    -15328.46   -15484.458   -15484.458    301.78842    301.78842    59603.265    59603.265   -839.11032   -839.11032 
Loop time of 462.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.548 hours/ns, 2.161 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    | 461.62     | 461.62     | 461.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21952    | 0.21952    | 0.21952    |   0.0 |  0.05
Output  | 0.00018429 | 0.00018429 | 0.00018429 |   0.0 |  0.00
Modify  | 0.82008    | 0.82008    | 0.82008    |   0.0 |  0.18
Other   |            | 0.1095     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559538.0 ave      559538 max      559538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559538
Ave neighs/atom = 139.88450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.23168713942, Press = -1.3256125639166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -15328.46    -15328.46   -15484.458   -15484.458    301.78842    301.78842    59603.265    59603.265   -839.11032   -839.11032 
   42000   -15321.152   -15321.152   -15484.342   -15484.342    315.70105    315.70105    59619.419    59619.419   -1220.7484   -1220.7484 
Loop time of 419.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.638 hours/ns, 2.382 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    | 418.86     | 418.86     | 418.86     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20509    | 0.20509    | 0.20509    |   0.0 |  0.05
Output  | 0.00018444 | 0.00018444 | 0.00018444 |   0.0 |  0.00
Modify  | 0.72862    | 0.72862    | 0.72862    |   0.0 |  0.17
Other   |            | 0.1029     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559482.0 ave      559482 max      559482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559482
Ave neighs/atom = 139.87050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.183089106417, Press = -0.514569487190278
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -15321.152   -15321.152   -15484.342   -15484.342    315.70105    315.70105    59619.419    59619.419   -1220.7484   -1220.7484 
   43000   -15321.569   -15321.569    -15484.25    -15484.25    314.71778    314.71778    59589.269    59589.269   -415.38028   -415.38028 
Loop time of 394.26 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.517 hours/ns, 2.536 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.3      | 393.3      | 393.3      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19528    | 0.19528    | 0.19528    |   0.0 |  0.05
Output  | 0.00018037 | 0.00018037 | 0.00018037 |   0.0 |  0.00
Modify  | 0.66819    | 0.66819    | 0.66819    |   0.0 |  0.17
Other   |            | 0.09668    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559416.0 ave      559416 max      559416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559416
Ave neighs/atom = 139.85400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.166960904266, Press = -0.371241980528261
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -15321.569   -15321.569    -15484.25    -15484.25    314.71778    314.71778    59589.269    59589.269   -415.38028   -415.38028 
   44000   -15322.213   -15322.213   -15485.319   -15485.319    315.53968    315.53968    59574.602    59574.602    106.98905    106.98905 
Loop time of 395.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.796 hours/ns, 2.530 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    | 394.31     | 394.31     | 394.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19305    | 0.19305    | 0.19305    |   0.0 |  0.05
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.67017    | 0.67017    | 0.67017    |   0.0 |  0.17
Other   |            | 0.09832    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559486.0 ave      559486 max      559486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559486
Ave neighs/atom = 139.87150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.233928204166, Press = -1.31993988948506
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -15322.213   -15322.213   -15485.319   -15485.319    315.53968    315.53968    59574.602    59574.602    106.98905    106.98905 
   45000    -15319.13    -15319.13    -15482.26    -15482.26    315.58547    315.58547    59584.227    59584.227     18.51439     18.51439 
Loop time of 395.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.903 hours/ns, 2.527 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394.69     | 394.69     | 394.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19415    | 0.19415    | 0.19415    |   0.0 |  0.05
Output  | 0.00018198 | 0.00018198 | 0.00018198 |   0.0 |  0.00
Modify  | 0.66886    | 0.66886    | 0.66886    |   0.0 |  0.17
Other   |            | 0.09791    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559530.0 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.88250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.243421412955, Press = -0.90423858401199
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -15319.13    -15319.13    -15482.26    -15482.26    315.58547    315.58547    59584.227    59584.227     18.51439     18.51439 
   46000   -15325.389   -15325.389   -15488.403   -15488.403    315.36229    315.36229     59535.46     59535.46     786.9858     786.9858 
Loop time of 416.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.657 hours/ns, 2.402 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    | 415.35     | 415.35     | 415.35     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19975    | 0.19975    | 0.19975    |   0.0 |  0.05
Output  | 0.00022844 | 0.00022844 | 0.00022844 |   0.0 |  0.00
Modify  | 0.71646    | 0.71646    | 0.71646    |   0.0 |  0.17
Other   |            | 0.1014     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8180.00 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559504.0 ave      559504 max      559504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559504
Ave neighs/atom = 139.87600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.275408865405, Press = -1.40654844273345
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -15325.389   -15325.389   -15488.403   -15488.403    315.36229    315.36229     59535.46     59535.46     786.9858     786.9858 
   47000   -15326.682   -15326.682   -15487.241   -15487.241    310.61146    310.61146    59538.116    59538.116    825.09377    825.09377 
Loop time of 406.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 112.945 hours/ns, 2.459 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    | 405.6      | 405.6      | 405.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19726    | 0.19726    | 0.19726    |   0.0 |  0.05
Output  | 0.00018342 | 0.00018342 | 0.00018342 |   0.0 |  0.00
Modify  | 0.7022     | 0.7022     | 0.7022     |   0.0 |  0.17
Other   |            | 0.102      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559546.0 ave      559546 max      559546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559546
Ave neighs/atom = 139.88650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.259631593689, Press = -1.88183487667305
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -15326.682   -15326.682   -15487.241   -15487.241    310.61146    310.61146    59538.116    59538.116    825.09377    825.09377 
   48000     -15323.7     -15323.7   -15483.802   -15483.802    309.72652    309.72652    59529.495    59529.495     1576.508     1576.508 
Loop time of 467.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.185 ns/day, 129.857 hours/ns, 2.139 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    | 466.31     | 466.31     | 466.31     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22032    | 0.22032    | 0.22032    |   0.0 |  0.05
Output  | 0.00028981 | 0.00028981 | 0.00028981 |   0.0 |  0.00
Modify  | 0.84546    | 0.84546    | 0.84546    |   0.0 |  0.18
Other   |            | 0.1114     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559580.0 ave      559580 max      559580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559580
Ave neighs/atom = 139.89500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.207454340784, Press = -0.766393571239222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000     -15323.7     -15323.7   -15483.802   -15483.802    309.72652    309.72652    59529.495    59529.495     1576.508     1576.508 
   49000   -15324.156   -15324.156   -15486.021   -15486.021     313.1381     313.1381    59518.543    59518.543    1741.6442    1741.6442 
Loop time of 404.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.438 hours/ns, 2.470 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    | 403.78     | 403.78     | 403.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19397    | 0.19397    | 0.19397    |   0.0 |  0.05
Output  | 0.00018061 | 0.00018061 | 0.00018061 |   0.0 |  0.00
Modify  | 0.69546    | 0.69546    | 0.69546    |   0.0 |  0.17
Other   |            | 0.1028     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559494.0 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.87350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.207522060001, Press = -1.21949999680416
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -15324.156   -15324.156   -15486.021   -15486.021     313.1381     313.1381    59518.543    59518.543    1741.6442    1741.6442 
   50000   -15321.949   -15321.949   -15485.341   -15485.341     316.0926     316.0926    59500.941    59500.941    2441.2947    2441.2947 
Loop time of 392.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.097 hours/ns, 2.546 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.79     | 391.79     | 391.79     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18989    | 0.18989    | 0.18989    |   0.0 |  0.05
Output  | 0.0001803  | 0.0001803  | 0.0001803  |   0.0 |  0.00
Modify  | 0.66805    | 0.66805    | 0.66805    |   0.0 |  0.17
Other   |            | 0.1007     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8178.00 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559590.0 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.89750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.184021940962, Press = -1.58701300878677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -15321.949   -15321.949   -15485.341   -15485.341     316.0926     316.0926    59500.941    59500.941    2441.2947    2441.2947 
   51000   -15325.439   -15325.439   -15484.479   -15484.479    307.67277    307.67277     59527.18     59527.18    1537.9892    1537.9892 
Loop time of 393.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.195 hours/ns, 2.544 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.15     | 392.15     | 392.15     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18997    | 0.18997    | 0.18997    |   0.0 |  0.05
Output  | 0.0001801  | 0.0001801  | 0.0001801  |   0.0 |  0.00
Modify  | 0.66679    | 0.66679    | 0.66679    |   0.0 |  0.17
Other   |            | 0.1001     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559618.0 ave      559618 max      559618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559618
Ave neighs/atom = 139.90450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.187344868508, Press = -1.69435514712273
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -15325.439   -15325.439   -15484.479   -15484.479    307.67277    307.67277     59527.18     59527.18    1537.9892    1537.9892 
   52000   -15321.091   -15321.091   -15483.637   -15483.637    314.45713    314.45713    59623.621    59623.621    -1284.525    -1284.525 
Loop time of 392.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.124 hours/ns, 2.546 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.89     | 391.89     | 391.89     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1898     | 0.1898     | 0.1898     |   0.0 |  0.05
Output  | 0.00018155 | 0.00018155 | 0.00018155 |   0.0 |  0.00
Modify  | 0.66648    | 0.66648    | 0.66648    |   0.0 |  0.17
Other   |            | 0.1009     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8189.00 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559530.0 ave      559530 max      559530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559530
Ave neighs/atom = 139.88250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.181042027275, Press = -1.24669116118229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -15321.091   -15321.091   -15483.637   -15483.637    314.45713    314.45713    59623.621    59623.621    -1284.525    -1284.525 
   53000   -15325.256   -15325.256   -15484.263   -15484.263    307.61005    307.61005    59624.095    59624.095   -1623.0765   -1623.0765 
Loop time of 393.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.177 hours/ns, 2.544 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.08     | 392.08     | 392.08     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19064    | 0.19064    | 0.19064    |   0.0 |  0.05
Output  | 0.00017993 | 0.00017993 | 0.00017993 |   0.0 |  0.00
Modify  | 0.66644    | 0.66644    | 0.66644    |   0.0 |  0.17
Other   |            | 0.1009     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559472.0 ave      559472 max      559472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559472
Ave neighs/atom = 139.86800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.19043004693, Press = -1.12832866114513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -15325.256   -15325.256   -15484.263   -15484.263    307.61005    307.61005    59624.095    59624.095   -1623.0765   -1623.0765 
   54000   -15322.259   -15322.259   -15483.789   -15483.789    312.49114    312.49114     59578.47     59578.47    78.683253    78.683253 
Loop time of 393.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.183 hours/ns, 2.544 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.1      | 392.1      | 392.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19116    | 0.19116    | 0.19116    |   0.0 |  0.05
Output  | 0.00018155 | 0.00018155 | 0.00018155 |   0.0 |  0.00
Modify  | 0.666      | 0.666      | 0.666      |   0.0 |  0.17
Other   |            | 0.1017     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8187.00 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559494.0 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.87350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.210469574998, Press = -0.60987841765873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -15322.259   -15322.259   -15483.789   -15483.789    312.49114    312.49114     59578.47     59578.47    78.683253    78.683253 
   55000   -15322.784   -15322.784   -15484.697   -15484.697    313.23299    313.23299    59580.285    59580.285   -153.01803   -153.01803 
Loop time of 393.139 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.205 hours/ns, 2.544 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.18     | 392.18     | 392.18     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18944    | 0.18944    | 0.18944    |   0.0 |  0.05
Output  | 0.00018132 | 0.00018132 | 0.00018132 |   0.0 |  0.00
Modify  | 0.66867    | 0.66867    | 0.66867    |   0.0 |  0.17
Other   |            | 0.1001     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559546.0 ave      559546 max      559546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559546
Ave neighs/atom = 139.88650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.199312145381, Press = -1.1030037024713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -15322.784   -15322.784   -15484.697   -15484.697    313.23299    313.23299    59580.285    59580.285   -153.01803   -153.01803 
   56000   -15323.573   -15323.573   -15483.551   -15483.551     309.4883     309.4883    59592.212    59592.212   -388.89419   -388.89419 
Loop time of 393.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.269 hours/ns, 2.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.4      | 392.4      | 392.4      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19139    | 0.19139    | 0.19139    |   0.0 |  0.05
Output  | 0.00017952 | 0.00017952 | 0.00017952 |   0.0 |  0.00
Modify  | 0.67061    | 0.67061    | 0.67061    |   0.0 |  0.17
Other   |            | 0.1013     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8181.00 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559508.0 ave      559508 max      559508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559508
Ave neighs/atom = 139.87700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.219148153484, Press = -1.38603764113691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -15323.573   -15323.573   -15483.551   -15483.551     309.4883     309.4883    59592.212    59592.212   -388.89419   -388.89419 
   57000    -15318.08    -15318.08   -15485.054   -15485.054    323.02366    323.02366    59655.487    59655.487   -2318.1631   -2318.1631 
Loop time of 393.466 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.296 hours/ns, 2.542 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.5      | 392.5      | 392.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1915     | 0.1915     | 0.1915     |   0.0 |  0.05
Output  | 0.00017991 | 0.00017991 | 0.00017991 |   0.0 |  0.00
Modify  | 0.67184    | 0.67184    | 0.67184    |   0.0 |  0.17
Other   |            | 0.1014     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559466.0 ave      559466 max      559466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559466
Ave neighs/atom = 139.86650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.239041695047, Press = -1.29664134179112
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000    -15318.08    -15318.08   -15485.054   -15485.054    323.02366    323.02366    59655.487    59655.487   -2318.1631   -2318.1631 
   58000   -15326.182   -15326.182   -15484.319   -15484.319    305.92701    305.92701    59637.308    59637.308   -1800.7643   -1800.7643 
Loop time of 393.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.348 hours/ns, 2.540 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    | 392.69     | 392.69     | 392.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19095    | 0.19095    | 0.19095    |   0.0 |  0.05
Output  | 0.00017978 | 0.00017978 | 0.00017978 |   0.0 |  0.00
Modify  | 0.67044    | 0.67044    | 0.67044    |   0.0 |  0.17
Other   |            | 0.1021     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8177.00 ave        8177 max        8177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559412.0 ave      559412 max      559412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559412
Ave neighs/atom = 139.85300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.253468866631, Press = -0.899429021166409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -15326.182   -15326.182   -15484.319   -15484.319    305.92701    305.92701    59637.308    59637.308   -1800.7643   -1800.7643 
   59000   -15320.323   -15320.323   -15480.928   -15480.928    310.70245    310.70245    59622.394    59622.394   -1057.6203   -1057.6203 
Loop time of 393.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.342 hours/ns, 2.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.67     | 392.67     | 392.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19228    | 0.19228    | 0.19228    |   0.0 |  0.05
Output  | 0.00024174 | 0.00024174 | 0.00024174 |   0.0 |  0.00
Modify  | 0.6701     | 0.6701     | 0.6701     |   0.0 |  0.17
Other   |            | 0.1013     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559456.0 ave      559456 max      559456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559456
Ave neighs/atom = 139.86400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.273105028054, Press = -0.783026439397027
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -15320.323   -15320.323   -15480.928   -15480.928    310.70245    310.70245    59622.394    59622.394   -1057.6203   -1057.6203 
   60000   -15323.462   -15323.462   -15485.058   -15485.058      312.619      312.619    59592.196    59592.196   -498.74358   -498.74358 
Loop time of 393.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.211 hours/ns, 2.543 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.2      | 392.2      | 392.2      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19118    | 0.19118    | 0.19118    |   0.0 |  0.05
Output  | 0.00018026 | 0.00018026 | 0.00018026 |   0.0 |  0.00
Modify  | 0.67095    | 0.67095    | 0.67095    |   0.0 |  0.17
Other   |            | 0.1012     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8172.00 ave        8172 max        8172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559488.0 ave      559488 max      559488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559488
Ave neighs/atom = 139.87200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.271464601981, Press = -0.387731229519405
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -15323.462   -15323.462   -15485.058   -15485.058      312.619      312.619    59592.196    59592.196   -498.74358   -498.74358 
   61000   -15327.671   -15327.671    -15491.45    -15491.45    316.84195    316.84195    59575.688    59575.688   -764.53155   -764.53155 
Loop time of 394.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.515 hours/ns, 2.536 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.29     | 393.29     | 393.29     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19026    | 0.19026    | 0.19026    |   0.0 |  0.05
Output  | 0.00018053 | 0.00018053 | 0.00018053 |   0.0 |  0.00
Modify  | 0.67299    | 0.67299    | 0.67299    |   0.0 |  0.17
Other   |            | 0.1005     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8183.00 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559462.0 ave      559462 max      559462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559462
Ave neighs/atom = 139.86550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.267801378113, Press = -0.689092761462001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -15327.671   -15327.671    -15491.45    -15491.45    316.84195    316.84195    59575.688    59575.688   -764.53155   -764.53155 
   62000   -15320.949   -15320.949   -15484.501   -15484.501    316.40236    316.40236    59552.359    59552.359    872.43931    872.43931 
Loop time of 393.63 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.342 hours/ns, 2.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.67     | 392.67     | 392.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19149    | 0.19149    | 0.19149    |   0.0 |  0.05
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.67022    | 0.67022    | 0.67022    |   0.0 |  0.17
Other   |            | 0.1021     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8179.00 ave        8179 max        8179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559594.0 ave      559594 max      559594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559594
Ave neighs/atom = 139.89850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.24069282487, Press = -0.527377800686516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -15320.949   -15320.949   -15484.501   -15484.501    316.40236    316.40236    59552.359    59552.359    872.43931    872.43931 
   63000   -15323.915   -15323.915   -15486.671   -15486.671    314.86403    314.86403    59556.262    59556.262    530.39285    530.39285 
Loop time of 393.422 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.284 hours/ns, 2.542 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.46     | 392.46     | 392.46     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19203    | 0.19203    | 0.19203    |   0.0 |  0.05
Output  | 0.00018087 | 0.00018087 | 0.00018087 |   0.0 |  0.00
Modify  | 0.66943    | 0.66943    | 0.66943    |   0.0 |  0.17
Other   |            | 0.1019     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8184.00 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559566.0 ave      559566 max      559566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559566
Ave neighs/atom = 139.89150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.237070965112, Press = -1.33165419862731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -15323.915   -15323.915   -15486.671   -15486.671    314.86403    314.86403    59556.262    59556.262    530.39285    530.39285 
   64000   -15325.202   -15325.202   -15485.726   -15485.726    310.54387    310.54387    59562.756    59562.756    390.18382    390.18382 
Loop time of 393.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.324 hours/ns, 2.541 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    | 392.6      | 392.6      | 392.6      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19119    | 0.19119    | 0.19119    |   0.0 |  0.05
Output  | 0.00017915 | 0.00017915 | 0.00017915 |   0.0 |  0.00
Modify  | 0.6729     | 0.6729     | 0.6729     |   0.0 |  0.17
Other   |            | 0.1003     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8182.00 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559604.0 ave      559604 max      559604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559604
Ave neighs/atom = 139.90100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.272285244537, Press = -0.637644391697559
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -15325.202   -15325.202   -15485.726   -15485.726    310.54387    310.54387    59562.756    59562.756    390.18382    390.18382 
   65000   -15321.884   -15321.884   -15485.279   -15485.279    316.09958    316.09958    59563.677    59563.677     462.2499     462.2499 
Loop time of 393.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.288 hours/ns, 2.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.47     | 392.47     | 392.47     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19249    | 0.19249    | 0.19249    |   0.0 |  0.05
Output  | 0.00023828 | 0.00023828 | 0.00023828 |   0.0 |  0.00
Modify  | 0.67165    | 0.67165    | 0.67165    |   0.0 |  0.17
Other   |            | 0.101      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8185.00 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559560.0 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.274582717197, Press = -0.407240224957607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -15321.884   -15321.884   -15485.279   -15485.279    316.09958    316.09958    59563.677    59563.677     462.2499     462.2499 
   66000   -15326.453   -15326.453    -15486.71    -15486.71    310.02845    310.02845     59565.56     59565.56     218.7885     218.7885 
Loop time of 393.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.199 hours/ns, 2.544 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    | 392.15     | 392.15     | 392.15     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19126    | 0.19126    | 0.19126    |   0.0 |  0.05
Output  | 0.00018126 | 0.00018126 | 0.00018126 |   0.0 |  0.00
Modify  | 0.67216    | 0.67216    | 0.67216    |   0.0 |  0.17
Other   |            | 0.1016     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8188.00 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559536.0 ave      559536 max      559536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559536
Ave neighs/atom = 139.88400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.248564104216, Press = -0.521698532377785
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -15326.453   -15326.453    -15486.71    -15486.71    310.02845    310.02845     59565.56     59565.56     218.7885     218.7885 
   67000    -15322.52    -15322.52   -15485.964   -15485.964    316.19237    316.19237    59557.952    59557.952    382.42086    382.42086 
Loop time of 432.545 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.151 hours/ns, 2.312 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    | 431.48     | 431.48     | 431.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20857    | 0.20857    | 0.20857    |   0.0 |  0.05
Output  | 0.0001693  | 0.0001693  | 0.0001693  |   0.0 |  0.00
Modify  | 0.75131    | 0.75131    | 0.75131    |   0.0 |  0.17
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559588.0 ave      559588 max      559588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559588
Ave neighs/atom = 139.89700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.219919467782, Press = -0.43379003108475
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -15322.52    -15322.52   -15485.964   -15485.964    316.19237    316.19237    59557.952    59557.952    382.42086    382.42086 
   68000   -15323.094   -15323.094   -15486.132   -15486.132    315.40807    315.40807    59557.764    59557.764    473.08213    473.08213 
Loop time of 462.845 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.568 hours/ns, 2.161 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    | 461.68     | 461.68     | 461.68     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22289    | 0.22289    | 0.22289    |   0.0 |  0.05
Output  | 0.00017303 | 0.00017303 | 0.00017303 |   0.0 |  0.00
Modify  | 0.82597    | 0.82597    | 0.82597    |   0.0 |  0.18
Other   |            | 0.1129     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8186.00 ave        8186 max        8186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      559516.0 ave      559516 max      559516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559516
Ave neighs/atom = 139.87900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
59576.8118379953

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0