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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.5175609808 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_196726067688_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8499.0849   -8499.0849        -8580        -8580       313.15       313.15    23483.518    23483.518    3680.3085    3680.3085 
    1000   -8414.1219   -8414.1219   -8492.0814   -8492.0814    301.71133    301.71133    23712.672    23712.672    2523.2822    2523.2822 
Loop time of 95.5963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.555 hours/ns, 10.461 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    | 95.12      | 95.12      | 95.12      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076574   | 0.076574   | 0.076574   |   0.0 |  0.08
Output  | 0.00019779 | 0.00019779 | 0.00019779 |   0.0 |  0.00
Modify  | 0.34383    | 0.34383    | 0.34383    |   0.0 |  0.36
Other   |            | 0.05611    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8414.1219   -8414.1219   -8492.0814   -8492.0814    301.71133    301.71133    23712.672    23712.672    2523.2822    2523.2822 
    2000   -8414.8534   -8414.8534   -8494.1062   -8494.1062    306.71653    306.71653    23745.579    23745.579   -78.206887   -78.206887 
Loop time of 98.1149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.254 hours/ns, 10.192 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    | 97.64      | 97.64      | 97.64      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075841   | 0.075841   | 0.075841   |   0.0 |  0.08
Output  | 0.00018433 | 0.00018433 | 0.00018433 |   0.0 |  0.00
Modify  | 0.34212    | 0.34212    | 0.34212    |   0.0 |  0.35
Other   |            | 0.05631    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116972.0 ave      116972 max      116972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116972
Ave neighs/atom = 58.486000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8414.8534   -8414.8534   -8494.1062   -8494.1062    306.71653    306.71653    23745.579    23745.579   -78.206887   -78.206887 
    3000   -8416.0672   -8416.0672   -8493.0456   -8493.0456    297.91456    297.91456    23762.447    23762.447   -1170.6209   -1170.6209 
Loop time of 98.2576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.294 hours/ns, 10.177 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    | 97.78      | 97.78      | 97.78      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075049   | 0.075049   | 0.075049   |   0.0 |  0.08
Output  | 0.00024604 | 0.00024604 | 0.00024604 |   0.0 |  0.00
Modify  | 0.34521    | 0.34521    | 0.34521    |   0.0 |  0.35
Other   |            | 0.05698    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116838.0 ave      116838 max      116838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116838
Ave neighs/atom = 58.419000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8416.0672   -8416.0672   -8493.0456   -8493.0456    297.91456    297.91456    23762.447    23762.447   -1170.6209   -1170.6209 
    4000    -8413.353    -8413.353   -8496.8365   -8496.8365    323.08976    323.08976    23761.459    23761.459   -1412.6949   -1412.6949 
Loop time of 98.2267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.285 hours/ns, 10.181 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.747     | 97.747     | 97.747     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076628   | 0.076628   | 0.076628   |   0.0 |  0.08
Output  | 0.00019019 | 0.00019019 | 0.00019019 |   0.0 |  0.00
Modify  | 0.34564    | 0.34564    | 0.34564    |   0.0 |  0.35
Other   |            | 0.05674    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2968.00 ave        2968 max        2968 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116784.0 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8413.353    -8413.353   -8496.8365   -8496.8365    323.08976    323.08976    23761.459    23761.459   -1412.6949   -1412.6949 
    5000   -8416.5576   -8416.5576   -8495.3883   -8495.3883     305.0827     305.0827    23742.993    23742.993   -88.171003   -88.171003 
Loop time of 99.7388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.705 hours/ns, 10.026 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.251     | 99.251     | 99.251     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076274   | 0.076274   | 0.076274   |   0.0 |  0.08
Output  | 0.00014992 | 0.00014992 | 0.00014992 |   0.0 |  0.00
Modify  | 0.35375    | 0.35375    | 0.35375    |   0.0 |  0.35
Other   |            | 0.05723    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116782.0 ave      116782 max      116782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116782
Ave neighs/atom = 58.391000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.826563514561, Press = 1065.60938875907
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8416.5576   -8416.5576   -8495.3883   -8495.3883     305.0827     305.0827    23742.993    23742.993   -88.171003   -88.171003 
    6000   -8414.2285   -8414.2285   -8495.7759   -8495.7759    315.59681    315.59681    23712.467    23712.467    1980.5312    1980.5312 
Loop time of 98.1945 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.276 hours/ns, 10.184 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    | 97.701     | 97.701     | 97.701     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076123   | 0.076123   | 0.076123   |   0.0 |  0.08
Output  | 0.00015294 | 0.00015294 | 0.00015294 |   0.0 |  0.00
Modify  | 0.36038    | 0.36038    | 0.36038    |   0.0 |  0.37
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116752.0 ave      116752 max      116752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116752
Ave neighs/atom = 58.376000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.809320421283, Press = 138.897558628646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8414.2285   -8414.2285   -8495.7759   -8495.7759    315.59681    315.59681    23712.467    23712.467    1980.5312    1980.5312 
    7000   -8416.8172   -8416.8172   -8495.4712   -8495.4712     304.3992     304.3992    23696.018    23696.018    3117.0464    3117.0464 
Loop time of 99.1176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.533 hours/ns, 10.089 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    | 98.618     | 98.618     | 98.618     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076808   | 0.076808   | 0.076808   |   0.0 |  0.08
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.36516    | 0.36516    | 0.36516    |   0.0 |  0.37
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116788.0 ave      116788 max      116788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116788
Ave neighs/atom = 58.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.47565399305, Press = 41.520558435485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8416.8172   -8416.8172   -8495.4712   -8495.4712     304.3992     304.3992    23696.018    23696.018    3117.0464    3117.0464 
    8000   -8411.5449   -8411.5449    -8494.778    -8494.778    322.12072    322.12072    23734.003    23734.003    931.97869    931.97869 
Loop time of 98.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.469 hours/ns, 10.112 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    | 98.39      | 98.39      | 98.39      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075987   | 0.075987   | 0.075987   |   0.0 |  0.08
Output  | 0.0001526  | 0.0001526  | 0.0001526  |   0.0 |  0.00
Modify  | 0.36661    | 0.36661    | 0.36661    |   0.0 |  0.37
Other   |            | 0.05686    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116888.0 ave      116888 max      116888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116888
Ave neighs/atom = 58.444000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.288139854855, Press = 16.3270365194201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8411.5449   -8411.5449    -8494.778    -8494.778    322.12072    322.12072    23734.003    23734.003    931.97869    931.97869 
    9000   -8415.9759   -8415.9759   -8496.4591   -8496.4591    311.47823    311.47823     23733.12     23733.12    609.23696    609.23696 
Loop time of 99.1567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.544 hours/ns, 10.085 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    | 98.658     | 98.658     | 98.658     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075734   | 0.075734   | 0.075734   |   0.0 |  0.08
Output  | 0.00015076 | 0.00015076 | 0.00015076 |   0.0 |  0.00
Modify  | 0.36544    | 0.36544    | 0.36544    |   0.0 |  0.37
Other   |            | 0.05688    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116792.0 ave      116792 max      116792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116792
Ave neighs/atom = 58.396000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.47384856871, Press = 10.3045186277044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8415.9759   -8415.9759   -8496.4591   -8496.4591    311.47823    311.47823     23733.12     23733.12    609.23696    609.23696 
   10000   -8415.7979   -8415.7979   -8496.1675   -8496.1675     311.0384     311.0384    23747.534    23747.534   -546.38475   -546.38475 
Loop time of 99.0242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.507 hours/ns, 10.099 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    | 98.526     | 98.526     | 98.526     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075639   | 0.075639   | 0.075639   |   0.0 |  0.08
Output  | 0.00015045 | 0.00015045 | 0.00015045 |   0.0 |  0.00
Modify  | 0.36552    | 0.36552    | 0.36552    |   0.0 |  0.37
Other   |            | 0.0573     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2970.00 ave        2970 max        2970 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116778.0 ave      116778 max      116778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116778
Ave neighs/atom = 58.389000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.45284094379, Press = 4.9856866130488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8415.7979   -8415.7979   -8496.1675   -8496.1675     311.0384     311.0384    23747.534    23747.534   -546.38475   -546.38475 
   11000   -8413.7988   -8413.7988   -8496.1683   -8496.1683    318.77842    318.77842    23775.257    23775.257    -2352.217    -2352.217 
Loop time of 99.0831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.523 hours/ns, 10.093 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    | 98.583     | 98.583     | 98.583     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076701   | 0.076701   | 0.076701   |   0.0 |  0.08
Output  | 0.0001544  | 0.0001544  | 0.0001544  |   0.0 |  0.00
Modify  | 0.36572    | 0.36572    | 0.36572    |   0.0 |  0.37
Other   |            | 0.05748    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116808.0 ave      116808 max      116808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116808
Ave neighs/atom = 58.404000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.435630567628, Press = 3.5538492357192
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8413.7988   -8413.7988   -8496.1683   -8496.1683    318.77842    318.77842    23775.257    23775.257    -2352.217    -2352.217 
   12000   -8415.3914   -8415.3914    -8495.382    -8495.382    309.57158    309.57158    23787.979    23787.979   -3198.9764   -3198.9764 
Loop time of 97.7576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.155 hours/ns, 10.229 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    | 97.265     | 97.265     | 97.265     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075161   | 0.075161   | 0.075161   |   0.0 |  0.08
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.36117    | 0.36117    | 0.36117    |   0.0 |  0.37
Other   |            | 0.05657    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116750.0 ave      116750 max      116750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116750
Ave neighs/atom = 58.375000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.314952781247, Press = 10.4474838207165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8415.3914   -8415.3914    -8495.382    -8495.382    309.57158    309.57158    23787.979    23787.979   -3198.9764   -3198.9764 
   13000   -8415.8917   -8415.8917   -8495.5772   -8495.5772    308.39102    308.39102    23757.233    23757.233   -972.89594   -972.89594 
Loop time of 97.8545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.182 hours/ns, 10.219 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    | 97.363     | 97.363     | 97.363     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07485    | 0.07485    | 0.07485    |   0.0 |  0.08
Output  | 0.00019994 | 0.00019994 | 0.00019994 |   0.0 |  0.00
Modify  | 0.35946    | 0.35946    | 0.35946    |   0.0 |  0.37
Other   |            | 0.05651    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2952.00 ave        2952 max        2952 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116742.0 ave      116742 max      116742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116742
Ave neighs/atom = 58.371000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.380567173877, Press = 14.1291934404932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8415.8917   -8415.8917   -8495.5772   -8495.5772    308.39102    308.39102    23757.233    23757.233   -972.89594   -972.89594 
   14000   -8418.3065   -8418.3065   -8497.2816   -8497.2816    305.64165    305.64165    23725.373    23725.373    872.13853    872.13853 
Loop time of 98.7082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.419 hours/ns, 10.131 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    | 98.207     | 98.207     | 98.207     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076372   | 0.076372   | 0.076372   |   0.0 |  0.08
Output  | 0.00015672 | 0.00015672 | 0.00015672 |   0.0 |  0.00
Modify  | 0.36754    | 0.36754    | 0.36754    |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116738.0 ave      116738 max      116738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116738
Ave neighs/atom = 58.369000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38635526186, Press = 12.0028215118603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8418.3065   -8418.3065   -8497.2816   -8497.2816    305.64165    305.64165    23725.373    23725.373    872.13853    872.13853 
   15000   -8415.0802   -8415.0802   -8494.6488   -8494.6488    307.93864    307.93864    23708.676    23708.676    2665.2335    2665.2335 
Loop time of 98.8547 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.460 hours/ns, 10.116 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    | 98.353     | 98.353     | 98.353     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077238   | 0.077238   | 0.077238   |   0.0 |  0.08
Output  | 0.00036712 | 0.00036712 | 0.00036712 |   0.0 |  0.00
Modify  | 0.36694    | 0.36694    | 0.36694    |   0.0 |  0.37
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2971.00 ave        2971 max        2971 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116758.0 ave      116758 max      116758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116758
Ave neighs/atom = 58.379000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.942966004416, Press = 8.54280813671165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8415.0802   -8415.0802   -8494.6488   -8494.6488    307.93864    307.93864    23708.676    23708.676    2665.2335    2665.2335 
   16000   -8415.7944   -8415.7944   -8496.3566   -8496.3566    311.78435    311.78435    23687.588    23687.588    3866.9761    3866.9761 
Loop time of 99.2203 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.561 hours/ns, 10.079 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    | 98.718     | 98.718     | 98.718     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076704   | 0.076704   | 0.076704   |   0.0 |  0.08
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.36764    | 0.36764    | 0.36764    |   0.0 |  0.37
Other   |            | 0.05742    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116774.0 ave      116774 max      116774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.93189374839, Press = 1.47830268081634
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8415.7944   -8415.7944   -8496.3566   -8496.3566    311.78435    311.78435    23687.588    23687.588    3866.9761    3866.9761 
   17000   -8414.1458   -8414.1458   -8496.1662   -8496.1662     317.4275     317.4275    23721.438    23721.438    1508.8777    1508.8777 
Loop time of 99.2455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.568 hours/ns, 10.076 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    | 98.746     | 98.746     | 98.746     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075687   | 0.075687   | 0.075687   |   0.0 |  0.08
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.36601    | 0.36601    | 0.36601    |   0.0 |  0.37
Other   |            | 0.05751    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116912.0 ave      116912 max      116912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116912
Ave neighs/atom = 58.456000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.837514198069, Press = -2.49445832889879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8414.1458   -8414.1458   -8496.1662   -8496.1662     317.4275     317.4275    23721.438    23721.438    1508.8777    1508.8777 
   18000   -8418.0823   -8418.0823   -8497.0053   -8497.0053    305.44027    305.44027    23742.783    23742.783   -379.17027   -379.17027 
Loop time of 97.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.201 hours/ns, 10.212 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    | 97.43      | 97.43      | 97.43      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076385   | 0.076385   | 0.076385   |   0.0 |  0.08
Output  | 0.00015421 | 0.00015421 | 0.00015421 |   0.0 |  0.00
Modify  | 0.36212    | 0.36212    | 0.36212    |   0.0 |  0.37
Other   |            | 0.05666    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116830.0 ave      116830 max      116830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116830
Ave neighs/atom = 58.415000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.695042129271, Press = 1.07676075737044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8418.0823   -8418.0823   -8497.0053   -8497.0053    305.44027    305.44027    23742.783    23742.783   -379.17027   -379.17027 
   19000   -8413.3111   -8413.3111    -8495.461    -8495.461    317.92897    317.92897    23759.916    23759.916   -1135.1184   -1135.1184 
Loop time of 98.4922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.359 hours/ns, 10.153 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    | 97.995     | 97.995     | 97.995     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076032   | 0.076032   | 0.076032   |   0.0 |  0.08
Output  | 0.00018851 | 0.00018851 | 0.00018851 |   0.0 |  0.00
Modify  | 0.36423    | 0.36423    | 0.36423    |   0.0 |  0.37
Other   |            | 0.05689    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.646703137555, Press = 1.77143249334592
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8413.3111   -8413.3111    -8495.461    -8495.461    317.92897    317.92897    23759.916    23759.916   -1135.1184   -1135.1184 
   20000   -8412.6442   -8412.6442   -8495.4051   -8495.4051    320.29329    320.29329    23768.204    23768.204   -1718.6107   -1718.6107 
Loop time of 97.7451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.151 hours/ns, 10.231 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    | 97.251     | 97.251     | 97.251     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075908   | 0.075908   | 0.075908   |   0.0 |  0.08
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.36064    | 0.36064    | 0.36064    |   0.0 |  0.37
Other   |            | 0.05728    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2956.00 ave        2956 max        2956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116756.0 ave      116756 max      116756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116756
Ave neighs/atom = 58.378000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.650426635371, Press = 3.80720295328531
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8412.6442   -8412.6442   -8495.4051   -8495.4051    320.29329    320.29329    23768.204    23768.204   -1718.6107   -1718.6107 
   21000   -8415.1458   -8415.1458   -8496.4943   -8496.4943    314.82678    314.82678    23772.726    23772.726   -2309.0665   -2309.0665 
Loop time of 97.4532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.070 hours/ns, 10.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    | 96.962     | 96.962     | 96.962     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074854   | 0.074854   | 0.074854   |   0.0 |  0.08
Output  | 0.00015067 | 0.00015067 | 0.00015067 |   0.0 |  0.00
Modify  | 0.35939    | 0.35939    | 0.35939    |   0.0 |  0.37
Other   |            | 0.05656    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116806.0 ave      116806 max      116806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116806
Ave neighs/atom = 58.403000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.703291476151, Press = 6.14928115354374
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8415.1458   -8415.1458   -8496.4943   -8496.4943    314.82678    314.82678    23772.726    23772.726   -2309.0665   -2309.0665 
   22000   -8413.1997   -8413.1997   -8493.7426   -8493.7426    311.70911    311.70911     23777.25     23777.25    -2200.414    -2200.414 
Loop time of 98.1631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.268 hours/ns, 10.187 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    | 97.671     | 97.671     | 97.671     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075295   | 0.075295   | 0.075295   |   0.0 |  0.08
Output  | 0.00015494 | 0.00015494 | 0.00015494 |   0.0 |  0.00
Modify  | 0.36043    | 0.36043    | 0.36043    |   0.0 |  0.37
Other   |            | 0.05656    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116770.0 ave      116770 max      116770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116770
Ave neighs/atom = 58.385000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.816098064596, Press = 9.60362160059282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8413.1997   -8413.1997   -8493.7426   -8493.7426    311.70911    311.70911     23777.25     23777.25    -2200.414    -2200.414 
   23000   -8411.6548   -8411.6548   -8494.4658   -8494.4658    320.48691    320.48691    23742.818    23742.818    317.93061    317.93061 
Loop time of 97.7127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.142 hours/ns, 10.234 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    | 97.222     | 97.222     | 97.222     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07605    | 0.07605    | 0.07605    |   0.0 |  0.08
Output  | 0.0001565  | 0.0001565  | 0.0001565  |   0.0 |  0.00
Modify  | 0.35889    | 0.35889    | 0.35889    |   0.0 |  0.37
Other   |            | 0.05591    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2974.00 ave        2974 max        2974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116812.0 ave      116812 max      116812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116812
Ave neighs/atom = 58.406000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.892459351043, Press = 6.45606586018058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8411.6548   -8411.6548   -8494.4658   -8494.4658    320.48691    320.48691    23742.818    23742.818    317.93061    317.93061 
   24000   -8412.0308   -8412.0308   -8493.7536   -8493.7536     316.2754     316.2754    23741.238    23741.238    486.76599    486.76599 
Loop time of 98.0826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.245 hours/ns, 10.195 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    | 97.589     | 97.589     | 97.589     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075376   | 0.075376   | 0.075376   |   0.0 |  0.08
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.36069    | 0.36069    | 0.36069    |   0.0 |  0.37
Other   |            | 0.05733    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116732.0 ave      116732 max      116732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116732
Ave neighs/atom = 58.366000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968570339416, Press = 4.48613617571513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8412.0308   -8412.0308   -8493.7536   -8493.7536     316.2754     316.2754    23741.238    23741.238    486.76599    486.76599 
   25000   -8416.6091   -8416.6091   -8497.4053   -8497.4053    312.68976    312.68976    23727.021    23727.021     769.4652     769.4652 
Loop time of 98.3884 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.330 hours/ns, 10.164 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    | 97.892     | 97.892     | 97.892     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075415   | 0.075415   | 0.075415   |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36448    | 0.36448    | 0.36448    |   0.0 |  0.37
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116774.0 ave      116774 max      116774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.97418961581, Press = 4.16354309090304
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8416.6091   -8416.6091   -8497.4053   -8497.4053    312.68976    312.68976    23727.021    23727.021     769.4652     769.4652 
   26000   -8414.6535   -8414.6535   -8496.6517   -8496.6517    317.34172    317.34172    23706.258    23706.258    2451.9211    2451.9211 
Loop time of 98.3702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.325 hours/ns, 10.166 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    | 97.875     | 97.875     | 97.875     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075579   | 0.075579   | 0.075579   |   0.0 |  0.08
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.36274    | 0.36274    | 0.36274    |   0.0 |  0.37
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116840.0 ave      116840 max      116840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116840
Ave neighs/atom = 58.420000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.8229014873, Press = 3.10790296285691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8414.6535   -8414.6535   -8496.6517   -8496.6517    317.34172    317.34172    23706.258    23706.258    2451.9211    2451.9211 
   27000   -8416.3075   -8416.3075   -8496.8292   -8496.8292    311.62742    311.62742     23696.42     23696.42    3100.2732    3100.2732 
Loop time of 98.7897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.442 hours/ns, 10.123 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    | 98.294     | 98.294     | 98.294     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074971   | 0.074971   | 0.074971   |   0.0 |  0.08
Output  | 0.00015696 | 0.00015696 | 0.00015696 |   0.0 |  0.00
Modify  | 0.36367    | 0.36367    | 0.36367    |   0.0 |  0.37
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116848.0 ave      116848 max      116848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116848
Ave neighs/atom = 58.424000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.799381815159, Press = 0.283622925856101
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8416.3075   -8416.3075   -8496.8292   -8496.8292    311.62742    311.62742     23696.42     23696.42    3100.2732    3100.2732 
   28000   -8412.9753   -8412.9753   -8495.2858   -8495.2858     318.5501     318.5501    23740.367    23740.367     398.9841     398.9841 
Loop time of 97.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.058 hours/ns, 10.266 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    | 96.919     | 96.919     | 96.919     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075909   | 0.075909   | 0.075909   |   0.0 |  0.08
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.35792    | 0.35792    | 0.35792    |   0.0 |  0.37
Other   |            | 0.05691    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116826.0 ave      116826 max      116826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116826
Ave neighs/atom = 58.413000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.724322327679, Press = -0.823311083673751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8412.9753   -8412.9753   -8495.2858   -8495.2858     318.5501     318.5501    23740.367    23740.367     398.9841     398.9841 
   29000   -8415.0844   -8415.0844   -8497.8065   -8497.8065    320.14319    320.14319    23752.547    23752.547   -805.47762   -805.47762 
Loop time of 98.1133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.254 hours/ns, 10.192 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    | 97.617     | 97.617     | 97.617     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075831   | 0.075831   | 0.075831   |   0.0 |  0.08
Output  | 0.00015012 | 0.00015012 | 0.00015012 |   0.0 |  0.00
Modify  | 0.36268    | 0.36268    | 0.36268    |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116720.0 ave      116720 max      116720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116720
Ave neighs/atom = 58.360000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.73923742793, Press = 1.50776203599981
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8415.0844   -8415.0844   -8497.8065   -8497.8065    320.14319    320.14319    23752.547    23752.547   -805.47762   -805.47762 
   30000   -8410.8253   -8410.8253   -8491.6292   -8491.6292    312.71944    312.71944    23767.876    23767.876   -1070.9178   -1070.9178 
Loop time of 98.7234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.423 hours/ns, 10.129 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    | 98.221     | 98.221     | 98.221     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076296   | 0.076296   | 0.076296   |   0.0 |  0.08
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.36826    | 0.36826    | 0.36826    |   0.0 |  0.37
Other   |            | 0.05723    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116698.0 ave      116698 max      116698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116698
Ave neighs/atom = 58.349000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.867842088428, Press = 1.41248800130561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8410.8253   -8410.8253   -8491.6292   -8491.6292    312.71944    312.71944    23767.876    23767.876   -1070.9178   -1070.9178 
   31000    -8413.313    -8413.313   -8493.0683   -8493.0683    308.66102    308.66102    23765.208    23765.208   -1073.1886   -1073.1886 
Loop time of 99.2889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.580 hours/ns, 10.072 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    | 98.789     | 98.789     | 98.789     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0762     | 0.0762     | 0.0762     |   0.0 |  0.08
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.36666    | 0.36666    | 0.36666    |   0.0 |  0.37
Other   |            | 0.05731    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2957.00 ave        2957 max        2957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116732.0 ave      116732 max      116732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116732
Ave neighs/atom = 58.366000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.857026870233, Press = 2.81849820783188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -8413.313    -8413.313   -8493.0683   -8493.0683    308.66102    308.66102    23765.208    23765.208   -1073.1886   -1073.1886 
   32000   -8415.1843   -8415.1843   -8495.4326   -8495.4326    310.56951    310.56951    23771.574    23771.574   -1940.6083   -1940.6083 
Loop time of 98.143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.262 hours/ns, 10.189 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    | 97.651     | 97.651     | 97.651     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074867   | 0.074867   | 0.074867   |   0.0 |  0.08
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.35992    | 0.35992    | 0.35992    |   0.0 |  0.37
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.826624904018, Press = 4.22621438645088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8415.1843   -8415.1843   -8495.4326   -8495.4326    310.56951    310.56951    23771.574    23771.574   -1940.6083   -1940.6083 
   33000   -8414.7837   -8414.7837   -8496.2591   -8496.2591    315.31822    315.31822    23746.106    23746.106   -237.16251   -237.16251 
Loop time of 98.2999 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.306 hours/ns, 10.173 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    | 97.804     | 97.804     | 97.804     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075882   | 0.075882   | 0.075882   |   0.0 |  0.08
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.3627     | 0.3627     | 0.3627     |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116758.0 ave      116758 max      116758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116758
Ave neighs/atom = 58.379000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.736975940695, Press = 6.50088887327274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8414.7837   -8414.7837   -8496.2591   -8496.2591    315.31822    315.31822    23746.106    23746.106   -237.16251   -237.16251 
   34000   -8414.5159   -8414.5159   -8494.3993   -8494.3993    309.15698    309.15698    23727.688    23727.688    1126.8837    1126.8837 
Loop time of 98.5765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.382 hours/ns, 10.144 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    | 98.081     | 98.081     | 98.081     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076495   | 0.076495   | 0.076495   |   0.0 |  0.08
Output  | 0.00024421 | 0.00024421 | 0.00024421 |   0.0 |  0.00
Modify  | 0.3614     | 0.3614     | 0.3614     |   0.0 |  0.37
Other   |            | 0.0575     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116800.0 ave      116800 max      116800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116800
Ave neighs/atom = 58.400000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.707617217739, Press = 4.290303574468
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8414.5159   -8414.5159   -8494.3993   -8494.3993    309.15698    309.15698    23727.688    23727.688    1126.8837    1126.8837 
   35000   -8411.4796   -8411.4796   -8494.4728   -8494.4728     321.1923     321.1923    23726.587    23726.587     1419.359     1419.359 
Loop time of 98.8668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.463 hours/ns, 10.115 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    | 98.368     | 98.368     | 98.368     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076503   | 0.076503   | 0.076503   |   0.0 |  0.08
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.36547    | 0.36547    | 0.36547    |   0.0 |  0.37
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116864.0 ave      116864 max      116864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116864
Ave neighs/atom = 58.432000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.713456695635, Press = 2.56658000022235
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8411.4796   -8411.4796   -8494.4728   -8494.4728     321.1923     321.1923    23726.587    23726.587     1419.359     1419.359 
   36000   -8415.2457   -8415.2457   -8497.5205   -8497.5205    318.41187    318.41187    23723.933    23723.933    1090.7726    1090.7726 
Loop time of 98.6875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.413 hours/ns, 10.133 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    | 98.19      | 98.19      | 98.19      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075963   | 0.075963   | 0.075963   |   0.0 |  0.08
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.36406    | 0.36406    | 0.36406    |   0.0 |  0.37
Other   |            | 0.05762    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116828.0 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.785019874982, Press = 1.6508836951874
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8415.2457   -8415.2457   -8497.5205   -8497.5205    318.41187    318.41187    23723.933    23723.933    1090.7726    1090.7726 
   37000   -8410.3534   -8410.3534   -8493.2996   -8493.2996    321.01026    321.01026     23742.16     23742.16    515.18193    515.18193 
Loop time of 98.5603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.378 hours/ns, 10.146 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    | 98.064     | 98.064     | 98.064     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075889   | 0.075889   | 0.075889   |   0.0 |  0.08
Output  | 0.00019552 | 0.00019552 | 0.00019552 |   0.0 |  0.00
Modify  | 0.36339    | 0.36339    | 0.36339    |   0.0 |  0.37
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116778.0 ave      116778 max      116778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116778
Ave neighs/atom = 58.389000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.861666576222, Press = -0.0202313854520744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8410.3534   -8410.3534   -8493.2996   -8493.2996    321.01026    321.01026     23742.16     23742.16    515.18193    515.18193 
   38000   -8413.8542   -8413.8542   -8494.6079   -8494.6079    312.52507    312.52507    23771.159    23771.159   -1776.3654   -1776.3654 
Loop time of 98.2331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.287 hours/ns, 10.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    | 97.74      | 97.74      | 97.74      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076381   | 0.076381   | 0.076381   |   0.0 |  0.08
Output  | 0.00015581 | 0.00015581 | 0.00015581 |   0.0 |  0.00
Modify  | 0.36037    | 0.36037    | 0.36037    |   0.0 |  0.37
Other   |            | 0.05638    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116842.0 ave      116842 max      116842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116842
Ave neighs/atom = 58.421000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.893114289653, Press = -0.394743993156229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8413.8542   -8413.8542   -8494.6079   -8494.6079    312.52507    312.52507    23771.159    23771.159   -1776.3654   -1776.3654 
   39000   -8420.1968   -8420.1968   -8498.6429   -8498.6429    303.59417    303.59417    23769.624    23769.624   -2350.3538   -2350.3538 
Loop time of 99.2682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.575 hours/ns, 10.074 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    | 98.767     | 98.767     | 98.767     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076258   | 0.076258   | 0.076258   |   0.0 |  0.08
Output  | 0.00015366 | 0.00015366 | 0.00015366 |   0.0 |  0.00
Modify  | 0.36738    | 0.36738    | 0.36738    |   0.0 |  0.37
Other   |            | 0.05787    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116730.0 ave      116730 max      116730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116730
Ave neighs/atom = 58.365000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.859473625528, Press = 1.33065072151027
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8420.1968   -8420.1968   -8498.6429   -8498.6429    303.59417    303.59417    23769.624    23769.624   -2350.3538   -2350.3538 
   40000   -8414.5025   -8414.5025   -8495.8422   -8495.8422     314.7929     314.7929    23764.164    23764.164   -1508.8447   -1508.8447 
Loop time of 98.5571 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.377 hours/ns, 10.146 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    | 98.06      | 98.06      | 98.06      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075911   | 0.075911   | 0.075911   |   0.0 |  0.08
Output  | 0.00015248 | 0.00015248 | 0.00015248 |   0.0 |  0.00
Modify  | 0.36329    | 0.36329    | 0.36329    |   0.0 |  0.37
Other   |            | 0.05729    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2953.00 ave        2953 max        2953 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116658.0 ave      116658 max      116658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116658
Ave neighs/atom = 58.329000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.818579092829, Press = 2.19322222958826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8414.5025   -8414.5025   -8495.8422   -8495.8422     314.7929     314.7929    23764.164    23764.164   -1508.8447   -1508.8447 
   41000    -8415.545    -8415.545   -8494.9208   -8494.9208     307.1927     307.1927    23744.607    23744.607   -130.96615   -130.96615 
Loop time of 98.7666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.435 hours/ns, 10.125 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    | 98.269     | 98.269     | 98.269     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076362   | 0.076362   | 0.076362   |   0.0 |  0.08
Output  | 0.00047577 | 0.00047577 | 0.00047577 |   0.0 |  0.00
Modify  | 0.36352    | 0.36352    | 0.36352    |   0.0 |  0.37
Other   |            | 0.05714    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116720.0 ave      116720 max      116720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116720
Ave neighs/atom = 58.360000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.811798980833, Press = 2.26137394564216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000    -8415.545    -8415.545   -8494.9208   -8494.9208     307.1927     307.1927    23744.607    23744.607   -130.96615   -130.96615 
   42000   -8417.9226   -8417.9226   -8499.0613   -8499.0613    314.01508    314.01508      23744.6      23744.6   -689.32244   -689.32244 
Loop time of 97.9821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.217 hours/ns, 10.206 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    | 97.487     | 97.487     | 97.487     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076578   | 0.076578   | 0.076578   |   0.0 |  0.08
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.36145    | 0.36145    | 0.36145    |   0.0 |  0.37
Other   |            | 0.0565     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2975.00 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116896.0 ave      116896 max      116896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116896
Ave neighs/atom = 58.448000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.821220176422, Press = 1.96028446982089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8417.9226   -8417.9226   -8499.0613   -8499.0613    314.01508    314.01508      23744.6      23744.6   -689.32244   -689.32244 
   43000   -8413.6903   -8413.6903   -8494.3725   -8494.3725    312.24851    312.24851    23745.917    23745.917    81.724014    81.724014 
Loop time of 97.8681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.186 hours/ns, 10.218 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.375     | 97.375     | 97.375     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075268   | 0.075268   | 0.075268   |   0.0 |  0.08
Output  | 0.00019114 | 0.00019114 | 0.00019114 |   0.0 |  0.00
Modify  | 0.36099    | 0.36099    | 0.36099    |   0.0 |  0.37
Other   |            | 0.05706    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116714.0 ave      116714 max      116714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116714
Ave neighs/atom = 58.357000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.762624762331, Press = 2.24036076984281
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8413.6903   -8413.6903   -8494.3725   -8494.3725    312.24851    312.24851    23745.917    23745.917    81.724014    81.724014 
   44000   -8417.5732   -8417.5732   -8497.3141   -8497.3141    308.60529    308.60529    23712.473    23712.473    1778.7018    1778.7018 
Loop time of 98.4741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.354 hours/ns, 10.155 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    | 97.976     | 97.976     | 97.976     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07658    | 0.07658    | 0.07658    |   0.0 |  0.08
Output  | 0.00015033 | 0.00015033 | 0.00015033 |   0.0 |  0.00
Modify  | 0.36426    | 0.36426    | 0.36426    |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116798.0 ave      116798 max      116798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116798
Ave neighs/atom = 58.399000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.745301225908, Press = 2.86168787722199
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8417.5732   -8417.5732   -8497.3141   -8497.3141    308.60529    308.60529    23712.473    23712.473    1778.7018    1778.7018 
   45000   -8412.1276   -8412.1276   -8495.4677   -8495.4677    322.53486    322.53486     23702.76     23702.76    3098.8008    3098.8008 
Loop time of 99.1229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.534 hours/ns, 10.088 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    | 98.621     | 98.621     | 98.621     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076426   | 0.076426   | 0.076426   |   0.0 |  0.08
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.36731    | 0.36731    | 0.36731    |   0.0 |  0.37
Other   |            | 0.05756    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116848.0 ave      116848 max      116848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116848
Ave neighs/atom = 58.424000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.708513997292, Press = 2.12878594941524
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8412.1276   -8412.1276   -8495.4677   -8495.4677    322.53486    322.53486     23702.76     23702.76    3098.8008    3098.8008 
   46000   -8419.1789   -8419.1789   -8497.9319   -8497.9319    304.78246    304.78246    23701.789    23701.789    2484.8996    2484.8996 
Loop time of 98.5931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.387 hours/ns, 10.143 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    | 98.097     | 98.097     | 98.097     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076575   | 0.076575   | 0.076575   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.36196    | 0.36196    | 0.36196    |   0.0 |  0.37
Other   |            | 0.05691    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2977.00 ave        2977 max        2977 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116870.0 ave      116870 max      116870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116870
Ave neighs/atom = 58.435000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.670955391045, Press = 1.05090776722783
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8419.1789   -8419.1789   -8497.9319   -8497.9319    304.78246    304.78246    23701.789    23701.789    2484.8996    2484.8996 
   47000   -8413.0685   -8413.0685   -8495.3293   -8495.3293    318.35797    318.35797    23731.645    23731.645    967.58715    967.58715 
Loop time of 98.7024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.417 hours/ns, 10.131 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    | 98.204     | 98.204     | 98.204     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076581   | 0.076581   | 0.076581   |   0.0 |  0.08
Output  | 0.00015304 | 0.00015304 | 0.00015304 |   0.0 |  0.00
Modify  | 0.36447    | 0.36447    | 0.36447    |   0.0 |  0.37
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2969.00 ave        2969 max        2969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116778.0 ave      116778 max      116778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116778
Ave neighs/atom = 58.389000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.648136844012, Press = 0.244443867465618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8413.0685   -8413.0685   -8495.3293   -8495.3293    318.35797    318.35797    23731.645    23731.645    967.58715    967.58715 
   48000   -8416.7847   -8416.7847   -8496.9365   -8496.9365    310.19586    310.19586    23741.198    23741.198   -22.277806   -22.277806 
Loop time of 98.3323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.315 hours/ns, 10.170 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    | 97.838     | 97.838     | 97.838     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07592    | 0.07592    | 0.07592    |   0.0 |  0.08
Output  | 0.0001521  | 0.0001521  | 0.0001521  |   0.0 |  0.00
Modify  | 0.36142    | 0.36142    | 0.36142    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2950.00 ave        2950 max        2950 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116770.0 ave      116770 max      116770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116770
Ave neighs/atom = 58.385000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.638589897739, Press = 0.688930533904517
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8416.7847   -8416.7847   -8496.9365   -8496.9365    310.19586    310.19586    23741.198    23741.198   -22.277806   -22.277806 
   49000   -8414.0137   -8414.0137   -8495.9072   -8495.9072    316.93624    316.93624    23751.668    23751.668   -489.57722   -489.57722 
Loop time of 97.8912 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.192 hours/ns, 10.215 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    | 97.398     | 97.398     | 97.398     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075366   | 0.075366   | 0.075366   |   0.0 |  0.08
Output  | 0.00018709 | 0.00018709 | 0.00018709 |   0.0 |  0.00
Modify  | 0.36079    | 0.36079    | 0.36079    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116834.0 ave      116834 max      116834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116834
Ave neighs/atom = 58.417000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.633194565592, Press = 1.00770518456667
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8414.0137   -8414.0137   -8495.9072   -8495.9072    316.93624    316.93624    23751.668    23751.668   -489.57722   -489.57722 
   50000   -8415.6092   -8415.6092   -8495.1181   -8495.1181    307.70787    307.70787    23758.404    23758.404   -1062.9229   -1062.9229 
Loop time of 98.7363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.427 hours/ns, 10.128 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    | 98.241     | 98.241     | 98.241     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076346   | 0.076346   | 0.076346   |   0.0 |  0.08
Output  | 0.00019751 | 0.00019751 | 0.00019751 |   0.0 |  0.00
Modify  | 0.36189    | 0.36189    | 0.36189    |   0.0 |  0.37
Other   |            | 0.05731    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116764.0 ave      116764 max      116764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116764
Ave neighs/atom = 58.382000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.646932982925, Press = 1.04436982808248
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8415.6092   -8415.6092   -8495.1181   -8495.1181    307.70787    307.70787    23758.404    23758.404   -1062.9229   -1062.9229 
   51000   -8414.7217   -8414.7217   -8494.7324   -8494.7324    309.64976    309.64976    23802.374    23802.374   -4064.2695   -4064.2695 
Loop time of 98.4501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.347 hours/ns, 10.157 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    | 97.953     | 97.953     | 97.953     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076187   | 0.076187   | 0.076187   |   0.0 |  0.08
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.3637     | 0.3637     | 0.3637     |   0.0 |  0.37
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116834.0 ave      116834 max      116834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116834
Ave neighs/atom = 58.417000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.67178708456, Press = 1.49085991423861
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8414.7217   -8414.7217   -8494.7324   -8494.7324    309.64976    309.64976    23802.374    23802.374   -4064.2695   -4064.2695 
   52000   -8410.1201   -8410.1201   -8494.7434   -8494.7434    327.50108    327.50108    23786.489    23786.489   -2778.5415   -2778.5415 
Loop time of 98.0642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.240 hours/ns, 10.197 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    | 97.57      | 97.57      | 97.57      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075832   | 0.075832   | 0.075832   |   0.0 |  0.08
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.36112    | 0.36112    | 0.36112    |   0.0 |  0.37
Other   |            | 0.0567     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116718.0 ave      116718 max      116718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116718
Ave neighs/atom = 58.359000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.703328747952, Press = 2.90435264884251
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8410.1201   -8410.1201   -8494.7434   -8494.7434    327.50108    327.50108    23786.489    23786.489   -2778.5415   -2778.5415 
   53000   -8415.4433   -8415.4433   -8495.4068   -8495.4068    309.46675    309.46675    23737.004    23737.004    361.21207    361.21207 
Loop time of 98.6971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.416 hours/ns, 10.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    | 98.199     | 98.199     | 98.199     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076126   | 0.076126   | 0.076126   |   0.0 |  0.08
Output  | 0.00015206 | 0.00015206 | 0.00015206 |   0.0 |  0.00
Modify  | 0.36557    | 0.36557    | 0.36557    |   0.0 |  0.37
Other   |            | 0.05669    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.748760304074, Press = 2.50194917615477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8415.4433   -8415.4433   -8495.4068   -8495.4068    309.46675    309.46675    23737.004    23737.004    361.21207    361.21207 
   54000   -8410.7026   -8410.7026   -8493.9082   -8493.9082    322.01421    322.01421    23736.808    23736.808    850.36724    850.36724 
Loop time of 98.9112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.475 hours/ns, 10.110 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    | 98.414     | 98.414     | 98.414     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076336   | 0.076336   | 0.076336   |   0.0 |  0.08
Output  | 0.0001554  | 0.0001554  | 0.0001554  |   0.0 |  0.00
Modify  | 0.36375    | 0.36375    | 0.36375    |   0.0 |  0.37
Other   |            | 0.0566     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.806123876878, Press = 1.84110816364287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8410.7026   -8410.7026   -8493.9082   -8493.9082    322.01421    322.01421    23736.808    23736.808    850.36724    850.36724 
   55000    -8415.028    -8415.028   -8495.2634   -8495.2634    310.51921    310.51921     23717.42     23717.42    1846.3407    1846.3407 
Loop time of 98.5722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.381 hours/ns, 10.145 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    | 98.076     | 98.076     | 98.076     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075569   | 0.075569   | 0.075569   |   0.0 |  0.08
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.36384    | 0.36384    | 0.36384    |   0.0 |  0.37
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2967.00 ave        2967 max        2967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116842.0 ave      116842 max      116842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116842
Ave neighs/atom = 58.421000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828227053398, Press = 1.49423827737138
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000    -8415.028    -8415.028   -8495.2634   -8495.2634    310.51921    310.51921     23717.42     23717.42    1846.3407    1846.3407 
   56000   -8414.7347   -8414.7347   -8496.7483   -8496.7483    317.40095    317.40095      23704.6      23704.6    2700.6667    2700.6667 
Loop time of 97.7819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.162 hours/ns, 10.227 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    | 97.286     | 97.286     | 97.286     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076927   | 0.076927   | 0.076927   |   0.0 |  0.08
Output  | 0.00015068 | 0.00015068 | 0.00015068 |   0.0 |  0.00
Modify  | 0.36221    | 0.36221    | 0.36221    |   0.0 |  0.37
Other   |            | 0.05673    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116836.0 ave      116836 max      116836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116836
Ave neighs/atom = 58.418000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850782191852, Press = -0.170535663518545
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8414.7347   -8414.7347   -8496.7483   -8496.7483    317.40095    317.40095      23704.6      23704.6    2700.6667    2700.6667 
   57000   -8413.8087   -8413.8087   -8497.5104   -8497.5104    323.93432    323.93432    23739.289    23739.289    80.856571    80.856571 
Loop time of 98.3272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.313 hours/ns, 10.170 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    | 97.832     | 97.832     | 97.832     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075696   | 0.075696   | 0.075696   |   0.0 |  0.08
Output  | 0.00015915 | 0.00015915 | 0.00015915 |   0.0 |  0.00
Modify  | 0.36301    | 0.36301    | 0.36301    |   0.0 |  0.37
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2952.00 ave        2952 max        2952 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116812.0 ave      116812 max      116812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116812
Ave neighs/atom = 58.406000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.856313439393, Press = -1.10347070070437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8413.8087   -8413.8087   -8497.5104   -8497.5104    323.93432    323.93432    23739.289    23739.289    80.856571    80.856571 
   58000   -8412.4254   -8412.4254   -8494.0047   -8494.0047     315.7203     315.7203    23768.148    23768.148   -1357.6483   -1357.6483 
Loop time of 97.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.194 hours/ns, 10.215 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    | 97.405     | 97.405     | 97.405     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075596   | 0.075596   | 0.075596   |   0.0 |  0.08
Output  | 0.00015076 | 0.00015076 | 0.00015076 |   0.0 |  0.00
Modify  | 0.36096    | 0.36096    | 0.36096    |   0.0 |  0.37
Other   |            | 0.05706    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116804.0 ave      116804 max      116804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116804
Ave neighs/atom = 58.402000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.871919729251, Press = 0.222009733034806
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8412.4254   -8412.4254   -8494.0047   -8494.0047     315.7203     315.7203    23768.148    23768.148   -1357.6483   -1357.6483 
   59000   -8413.5143   -8413.5143   -8494.5029   -8494.5029     313.4343     313.4343    23769.253    23769.253   -1688.8046   -1688.8046 
Loop time of 98.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.487 hours/ns, 10.106 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    | 98.451     | 98.451     | 98.451     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076847   | 0.076847   | 0.076847   |   0.0 |  0.08
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.36824    | 0.36824    | 0.36824    |   0.0 |  0.37
Other   |            | 0.05739    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116788.0 ave      116788 max      116788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116788
Ave neighs/atom = 58.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.87227273797, Press = 0.939677312117358
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8413.5143   -8413.5143   -8494.5029   -8494.5029     313.4343     313.4343    23769.253    23769.253   -1688.8046   -1688.8046 
   60000   -8417.6076   -8417.6076   -8497.5316   -8497.5316    309.31439    309.31439    23759.712    23759.712   -1596.7224   -1596.7224 
Loop time of 97.7015 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.139 hours/ns, 10.235 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    | 97.209     | 97.209     | 97.209     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075712   | 0.075712   | 0.075712   |   0.0 |  0.08
Output  | 0.00015253 | 0.00015253 | 0.00015253 |   0.0 |  0.00
Modify  | 0.36054    | 0.36054    | 0.36054    |   0.0 |  0.37
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116792.0 ave      116792 max      116792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116792
Ave neighs/atom = 58.396000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.849283776666, Press = 1.16708092765917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8417.6076   -8417.6076   -8497.5316   -8497.5316    309.31439    309.31439    23759.712    23759.712   -1596.7224   -1596.7224 
   61000   -8414.1894   -8414.1894    -8496.303    -8496.303    317.78819    317.78819    23783.009    23783.009    -2837.219    -2837.219 
Loop time of 97.6641 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.129 hours/ns, 10.239 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    | 97.171     | 97.171     | 97.171     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076894   | 0.076894   | 0.076894   |   0.0 |  0.08
Output  | 0.00019235 | 0.00019235 | 0.00019235 |   0.0 |  0.00
Modify  | 0.35867    | 0.35867    | 0.35867    |   0.0 |  0.37
Other   |            | 0.05692    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2972.00 ave        2972 max        2972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116688.0 ave      116688 max      116688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116688
Ave neighs/atom = 58.344000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.85033219777, Press = 1.84796758554188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8414.1894   -8414.1894    -8496.303    -8496.303    317.78819    317.78819    23783.009    23783.009    -2837.219    -2837.219 
   62000   -8416.0351   -8416.0351   -8496.7447   -8496.7447    312.35463    312.35463    23777.738    23777.738   -2637.8842   -2637.8842 
Loop time of 97.5792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.105 hours/ns, 10.248 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    | 97.085     | 97.085     | 97.085     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075752   | 0.075752   | 0.075752   |   0.0 |  0.08
Output  | 0.00019832 | 0.00019832 | 0.00019832 |   0.0 |  0.00
Modify  | 0.36156    | 0.36156    | 0.36156    |   0.0 |  0.37
Other   |            | 0.05696    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116784.0 ave      116784 max      116784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116784
Ave neighs/atom = 58.392000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.858789329912, Press = 3.38437376254801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8416.0351   -8416.0351   -8496.7447   -8496.7447    312.35463    312.35463    23777.738    23777.738   -2637.8842   -2637.8842 
   63000   -8414.4617   -8414.4617    -8495.273    -8495.273    312.74787    312.74787    23743.008    23743.008     87.21496     87.21496 
Loop time of 98.2273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.285 hours/ns, 10.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    | 97.732     | 97.732     | 97.732     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075609   | 0.075609   | 0.075609   |   0.0 |  0.08
Output  | 0.00015145 | 0.00015145 | 0.00015145 |   0.0 |  0.00
Modify  | 0.36278    | 0.36278    | 0.36278    |   0.0 |  0.37
Other   |            | 0.05685    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116758.0 ave      116758 max      116758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116758
Ave neighs/atom = 58.379000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.859621486664, Press = 2.87103903784067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8414.4617   -8414.4617    -8495.273    -8495.273    312.74787    312.74787    23743.008    23743.008     87.21496     87.21496 
   64000   -8417.1249   -8417.1249   -8496.8891   -8496.8891    308.69552    308.69552    23718.515    23718.515    1472.0304    1472.0304 
Loop time of 97.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.155 hours/ns, 10.229 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    | 97.268     | 97.268     | 97.268     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07453    | 0.07453    | 0.07453    |   0.0 |  0.08
Output  | 0.0001554  | 0.0001554  | 0.0001554  |   0.0 |  0.00
Modify  | 0.35858    | 0.35858    | 0.35858    |   0.0 |  0.37
Other   |            | 0.05658    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2965.00 ave        2965 max        2965 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116826.0 ave      116826 max      116826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116826
Ave neighs/atom = 58.413000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850583936646, Press = 2.44554999526109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8417.1249   -8417.1249   -8496.8891   -8496.8891    308.69552    308.69552    23718.515    23718.515    1472.0304    1472.0304 
   65000   -8416.8203   -8416.8203   -8496.6484   -8496.6484    308.94299    308.94299    23710.617    23710.617    2080.7995    2080.7995 
Loop time of 97.4613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.073 hours/ns, 10.260 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    | 96.97      | 96.97      | 96.97      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075612   | 0.075612   | 0.075612   |   0.0 |  0.08
Output  | 0.00019137 | 0.00019137 | 0.00019137 |   0.0 |  0.00
Modify  | 0.3593     | 0.3593     | 0.3593     |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116762.0 ave      116762 max      116762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116762
Ave neighs/atom = 58.381000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.86750480663, Press = 1.542023891478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8416.8203   -8416.8203   -8496.6484   -8496.6484    308.94299    308.94299    23710.617    23710.617    2080.7995    2080.7995 
   66000   -8415.3718   -8415.3718   -8494.9522   -8494.9522    307.98447    307.98447    23712.942    23712.942    2281.0404    2281.0404 
Loop time of 98.8673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.463 hours/ns, 10.115 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    | 98.367     | 98.367     | 98.367     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076351   | 0.076351   | 0.076351   |   0.0 |  0.08
Output  | 0.00014755 | 0.00014755 | 0.00014755 |   0.0 |  0.00
Modify  | 0.36615    | 0.36615    | 0.36615    |   0.0 |  0.37
Other   |            | 0.05722    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2971.00 ave        2971 max        2971 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116790.0 ave      116790 max      116790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116790
Ave neighs/atom = 58.395000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.912456303706, Press = 0.988667896974945
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8415.3718   -8415.3718   -8494.9522   -8494.9522    307.98447    307.98447    23712.942    23712.942    2281.0404    2281.0404 
   67000   -8414.3517   -8414.3517    -8495.794    -8495.794    315.18987    315.18987    23727.584    23727.584     1132.692     1132.692 
Loop time of 98.6025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.390 hours/ns, 10.142 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    | 98.107     | 98.107     | 98.107     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075262   | 0.075262   | 0.075262   |   0.0 |  0.08
Output  | 0.00048319 | 0.00048319 | 0.00048319 |   0.0 |  0.00
Modify  | 0.36355    | 0.36355    | 0.36355    |   0.0 |  0.37
Other   |            | 0.05671    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116782.0 ave      116782 max      116782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116782
Ave neighs/atom = 58.391000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.929151067639, Press = 0.483114262395256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8414.3517   -8414.3517    -8495.794    -8495.794    315.18987    315.18987    23727.584    23727.584     1132.692     1132.692 
   68000   -8419.1154   -8419.1154   -8499.2212   -8499.2212    310.01769    310.01769    23744.901    23744.901   -785.62378   -785.62378 
Loop time of 100.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.813 hours/ns, 9.987 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    | 99.618     | 99.618     | 99.618     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076969   | 0.076969   | 0.076969   |   0.0 |  0.08
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.37222    | 0.37222    | 0.37222    |   0.0 |  0.37
Other   |            | 0.058      |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116828.0 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889289745829, Press = 0.487555483635808
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8419.1154   -8419.1154   -8499.2212   -8499.2212    310.01769    310.01769    23744.901    23744.901   -785.62378   -785.62378 
   69000   -8413.7339   -8413.7339    -8496.193    -8496.193    319.12508    319.12508    23778.542    23778.542   -2560.1195   -2560.1195 
Loop time of 98.8576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.460 hours/ns, 10.116 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    | 98.358     | 98.358     | 98.358     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07611    | 0.07611    | 0.07611    |   0.0 |  0.08
Output  | 0.00015298 | 0.00015298 | 0.00015298 |   0.0 |  0.00
Modify  | 0.36583    | 0.36583    | 0.36583    |   0.0 |  0.37
Other   |            | 0.05741    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2961.00 ave        2961 max        2961 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116686.0 ave      116686 max      116686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116686
Ave neighs/atom = 58.343000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.885079963516, Press = 0.252437515607844
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8413.7339   -8413.7339    -8496.193    -8496.193    319.12508    319.12508    23778.542    23778.542   -2560.1195   -2560.1195 
   70000   -8411.2865   -8411.2865   -8493.3498   -8493.3498    317.59358    317.59358    23804.503    23804.503   -3908.7239   -3908.7239 
Loop time of 97.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.195 hours/ns, 10.214 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    | 97.41      | 97.41      | 97.41      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075005   | 0.075005   | 0.075005   |   0.0 |  0.08
Output  | 0.00025844 | 0.00025844 | 0.00025844 |   0.0 |  0.00
Modify  | 0.36055    | 0.36055    | 0.36055    |   0.0 |  0.37
Other   |            | 0.05707    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116728.0 ave      116728 max      116728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116728
Ave neighs/atom = 58.364000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.900656200193, Press = 1.04811526677112
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8411.2865   -8411.2865   -8493.3498   -8493.3498    317.59358    317.59358    23804.503    23804.503   -3908.7239   -3908.7239 
   71000   -8415.8783   -8415.8783   -8495.5141   -8495.5141    308.19884    308.19884    23773.913    23773.913   -2228.2078   -2228.2078 
Loop time of 98.5551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.376 hours/ns, 10.147 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    | 98.057     | 98.057     | 98.057     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075786   | 0.075786   | 0.075786   |   0.0 |  0.08
Output  | 0.00020323 | 0.00020323 | 0.00020323 |   0.0 |  0.00
Modify  | 0.36476    | 0.36476    | 0.36476    |   0.0 |  0.37
Other   |            | 0.05703    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116770.0 ave      116770 max      116770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116770
Ave neighs/atom = 58.385000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.934016330135, Press = 1.66133361550476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8415.8783   -8415.8783   -8495.5141   -8495.5141    308.19884    308.19884    23773.913    23773.913   -2228.2078   -2228.2078 
   72000   -8414.1489   -8414.1489   -8493.4334   -8493.4334    306.83905    306.83905    23753.268    23753.268   -325.93148   -325.93148 
Loop time of 98.9949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.499 hours/ns, 10.102 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    | 98.496     | 98.496     | 98.496     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075758   | 0.075758   | 0.075758   |   0.0 |  0.08
Output  | 0.00016057 | 0.00016057 | 0.00016057 |   0.0 |  0.00
Modify  | 0.3661     | 0.3661     | 0.3661     |   0.0 |  0.37
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2971.00 ave        2971 max        2971 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116774.0 ave      116774 max      116774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116774
Ave neighs/atom = 58.387000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968725859412, Press = 1.51539105993018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8414.1489   -8414.1489   -8493.4334   -8493.4334    306.83905    306.83905    23753.268    23753.268   -325.93148   -325.93148 
   73000   -8411.7549   -8411.7549   -8495.0778   -8495.0778     322.4685     322.4685    23755.249    23755.249   -598.39008   -598.39008 
Loop time of 98.1962 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.277 hours/ns, 10.184 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    | 97.704     | 97.704     | 97.704     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075281   | 0.075281   | 0.075281   |   0.0 |  0.08
Output  | 0.00015198 | 0.00015198 | 0.00015198 |   0.0 |  0.00
Modify  | 0.36024    | 0.36024    | 0.36024    |   0.0 |  0.37
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2958.00 ave        2958 max        2958 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116826.0 ave      116826 max      116826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116826
Ave neighs/atom = 58.413000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968863103562, Press = 1.47505871001964
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8411.7549   -8411.7549   -8495.0778   -8495.0778     322.4685     322.4685    23755.249    23755.249   -598.39008   -598.39008 
   74000   -8414.7617   -8414.7617   -8494.7791   -8494.7791    309.67558    309.67558    23746.875    23746.875   -202.28127   -202.28127 
Loop time of 99.1007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.528 hours/ns, 10.091 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    | 98.598     | 98.598     | 98.598     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077302   | 0.077302   | 0.077302   |   0.0 |  0.08
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.36759    | 0.36759    | 0.36759    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2971.00 ave        2971 max        2971 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116812.0 ave      116812 max      116812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116812
Ave neighs/atom = 58.406000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.020523059217, Press = 1.40125597774812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8414.7617   -8414.7617   -8494.7791   -8494.7791    309.67558    309.67558    23746.875    23746.875   -202.28127   -202.28127 
   75000   -8413.8664   -8413.8664   -8495.0872   -8495.0872     314.3329     314.3329    23736.573    23736.573    571.62238    571.62238 
Loop time of 98.5742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.382 hours/ns, 10.145 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    | 98.08      | 98.08      | 98.08      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075835   | 0.075835   | 0.075835   |   0.0 |  0.08
Output  | 0.00015228 | 0.00015228 | 0.00015228 |   0.0 |  0.00
Modify  | 0.36121    | 0.36121    | 0.36121    |   0.0 |  0.37
Other   |            | 0.05706    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2975.00 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116836.0 ave      116836 max      116836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116836
Ave neighs/atom = 58.418000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.018022256208, Press = 1.69758867690589
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8413.8664   -8413.8664   -8495.0872   -8495.0872     314.3329     314.3329    23736.573    23736.573    571.62238    571.62238 
   76000   -8417.4268   -8417.4268    -8496.938    -8496.938    307.71642    307.71642    23706.003    23706.003    2319.7527    2319.7527 
Loop time of 99.6922 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.692 hours/ns, 10.031 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.188     | 99.188     | 99.188     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076984   | 0.076984   | 0.076984   |   0.0 |  0.08
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.36929    | 0.36929    | 0.36929    |   0.0 |  0.37
Other   |            | 0.0574     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116828.0 ave      116828 max      116828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116828
Ave neighs/atom = 58.414000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.011847331639, Press = 1.89834006911091
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8417.4268   -8417.4268    -8496.938    -8496.938    307.71642    307.71642    23706.003    23706.003    2319.7527    2319.7527 
   77000   -8412.9904   -8412.9904    -8496.657    -8496.657    323.79855    323.79855    23701.573    23701.573    2817.0839    2817.0839 
Loop time of 97.923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.201 hours/ns, 10.212 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    | 97.429     | 97.429     | 97.429     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076079   | 0.076079   | 0.076079   |   0.0 |  0.08
Output  | 0.00015226 | 0.00015226 | 0.00015226 |   0.0 |  0.00
Modify  | 0.36068    | 0.36068    | 0.36068    |   0.0 |  0.37
Other   |            | 0.05701    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116792.0 ave      116792 max      116792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116792
Ave neighs/atom = 58.396000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.991872912139, Press = 1.35342285959726
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8412.9904   -8412.9904    -8496.657    -8496.657    323.79855    323.79855    23701.573    23701.573    2817.0839    2817.0839 
   78000   -8415.3334   -8415.3334    -8496.958    -8496.958    315.89528    315.89528     23714.78     23714.78     1817.416     1817.416 
Loop time of 97.7534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.154 hours/ns, 10.230 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    | 97.26      | 97.26      | 97.26      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075688   | 0.075688   | 0.075688   |   0.0 |  0.08
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.36027    | 0.36027    | 0.36027    |   0.0 |  0.37
Other   |            | 0.05715    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2960.00 ave        2960 max        2960 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116816.0 ave      116816 max      116816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116816
Ave neighs/atom = 58.408000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.019762162672, Press = 0.697522356185148
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -8415.3334   -8415.3334    -8496.958    -8496.958    315.89528    315.89528     23714.78     23714.78     1817.416     1817.416 
   79000   -8415.8697   -8415.8697   -8497.2039   -8497.2039    314.77177    314.77177    23728.639    23728.639     794.1808     794.1808 
Loop time of 98.1501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.264 hours/ns, 10.188 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    | 97.649     | 97.649     | 97.649     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075556   | 0.075556   | 0.075556   |   0.0 |  0.08
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.36426    | 0.36426    | 0.36426    |   0.0 |  0.37
Other   |            | 0.0608     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116798.0 ave      116798 max      116798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116798
Ave neighs/atom = 58.399000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.040334355183, Press = 0.625615229570982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -8415.8697   -8415.8697   -8497.2039   -8497.2039    314.77177    314.77177    23728.639    23728.639     794.1808     794.1808 
   80000   -8416.6285   -8416.6285   -8496.2422   -8496.2422    308.11305    308.11305    23740.477    23740.477    196.75453    196.75453 
Loop time of 98.3158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.310 hours/ns, 10.171 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    | 97.818     | 97.818     | 97.818     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076644   | 0.076644   | 0.076644   |   0.0 |  0.08
Output  | 0.00015768 | 0.00015768 | 0.00015768 |   0.0 |  0.00
Modify  | 0.36349    | 0.36349    | 0.36349    |   0.0 |  0.37
Other   |            | 0.05707    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2970.00 ave        2970 max        2970 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116786.0 ave      116786 max      116786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116786
Ave neighs/atom = 58.393000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.060296970269, Press = 0.534874917011826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -8416.6285   -8416.6285   -8496.2422   -8496.2422    308.11305    308.11305    23740.477    23740.477    196.75453    196.75453 
   81000   -8415.3849   -8415.3849   -8495.6569   -8495.6569    310.66115    310.66115    23749.867    23749.867   -401.03388   -401.03388 
Loop time of 97.5116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.087 hours/ns, 10.255 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.022     | 97.022     | 97.022     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075159   | 0.075159   | 0.075159   |   0.0 |  0.08
Output  | 0.00015964 | 0.00015964 | 0.00015964 |   0.0 |  0.00
Modify  | 0.35744    | 0.35744    | 0.35744    |   0.0 |  0.37
Other   |            | 0.05719    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2964.00 ave        2964 max        2964 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116772.0 ave      116772 max      116772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116772
Ave neighs/atom = 58.386000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.031446503536, Press = 0.750229910274339
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -8415.3849   -8415.3849   -8495.6569   -8495.6569    310.66115    310.66115    23749.867    23749.867   -401.03388   -401.03388 
   82000   -8412.4806   -8412.4806   -8492.9628   -8492.9628    311.47418    311.47418    23771.362    23771.362   -1513.4716   -1513.4716 
Loop time of 98.3927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.331 hours/ns, 10.163 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    | 97.893     | 97.893     | 97.893     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076672   | 0.076672   | 0.076672   |   0.0 |  0.08
Output  | 0.00015257 | 0.00015257 | 0.00015257 |   0.0 |  0.00
Modify  | 0.36543    | 0.36543    | 0.36543    |   0.0 |  0.37
Other   |            | 0.05756    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116788.0 ave      116788 max      116788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116788
Ave neighs/atom = 58.394000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.015841545357, Press = 0.279944749928047
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -8412.4806   -8412.4806   -8492.9628   -8492.9628    311.47418    311.47418    23771.362    23771.362   -1513.4716   -1513.4716 
   83000   -8420.8825   -8420.8825   -8497.3039   -8497.3039    295.75885    295.75885    23775.836    23775.836    -2671.887    -2671.887 
Loop time of 100.016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.782 hours/ns, 9.998 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    | 99.509     | 99.509     | 99.509     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07699    | 0.07699    | 0.07699    |   0.0 |  0.08
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.3718     | 0.3718     | 0.3718     |   0.0 |  0.37
Other   |            | 0.05803    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2959.00 ave        2959 max        2959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116702.0 ave      116702 max      116702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116702
Ave neighs/atom = 58.351000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.993634083144, Press = 0.700541963894029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -8420.8825   -8420.8825   -8497.3039   -8497.3039    295.75885    295.75885    23775.836    23775.836    -2671.887    -2671.887 
   84000   -8412.9598   -8412.9598   -8495.7989   -8495.7989     320.5959     320.5959    23788.944    23788.944   -3199.4669   -3199.4669 
Loop time of 99.4158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.616 hours/ns, 10.059 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    | 98.912     | 98.912     | 98.912     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076203   | 0.076203   | 0.076203   |   0.0 |  0.08
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.36996    | 0.36996    | 0.36996    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2955.00 ave        2955 max        2955 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116694.0 ave      116694 max      116694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116694
Ave neighs/atom = 58.347000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.982323259083, Press = 1.36538529669659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -8412.9598   -8412.9598   -8495.7989   -8495.7989     320.5959     320.5959    23788.944    23788.944   -3199.4669   -3199.4669 
   85000   -8417.5288   -8417.5288    -8496.031    -8496.031    303.81147    303.81147    23749.585    23749.585   -530.32833   -530.32833 
Loop time of 97.7781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.161 hours/ns, 10.227 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    | 97.284     | 97.284     | 97.284     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074723   | 0.074723   | 0.074723   |   0.0 |  0.08
Output  | 0.00015246 | 0.00015246 | 0.00015246 |   0.0 |  0.00
Modify  | 0.36225    | 0.36225    | 0.36225    |   0.0 |  0.37
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116796.0 ave      116796 max      116796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116796
Ave neighs/atom = 58.398000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.981399507369, Press = 1.54307253688163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -8417.5288   -8417.5288    -8496.031    -8496.031    303.81147    303.81147    23749.585    23749.585   -530.32833   -530.32833 
   86000   -8415.0998   -8415.0998     -8494.35     -8494.35    306.70668    306.70668    23739.482    23739.482    396.78323    396.78323 
Loop time of 99.6703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.686 hours/ns, 10.033 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    | 99.168     | 99.168     | 99.168     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076874   | 0.076874   | 0.076874   |   0.0 |  0.08
Output  | 0.00015681 | 0.00015681 | 0.00015681 |   0.0 |  0.00
Modify  | 0.36762    | 0.36762    | 0.36762    |   0.0 |  0.37
Other   |            | 0.05769    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116724.0 ave      116724 max      116724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116724
Ave neighs/atom = 58.362000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.974043945606, Press = 1.21739924333163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8415.0998   -8415.0998     -8494.35     -8494.35    306.70668    306.70668    23739.482    23739.482    396.78323    396.78323 
   87000   -8417.9705   -8417.9705   -8498.5149   -8498.5149    311.71531    311.71531    23732.883    23732.883    251.50088    251.50088 
Loop time of 99.0075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.502 hours/ns, 10.100 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.507     | 98.507     | 98.507     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075608   | 0.075608   | 0.075608   |   0.0 |  0.08
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.36695    | 0.36695    | 0.36695    |   0.0 |  0.37
Other   |            | 0.05815    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116832.0 ave      116832 max      116832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116832
Ave neighs/atom = 58.416000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.982022753768, Press = 1.10228426509201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8417.9705   -8417.9705   -8498.5149   -8498.5149    311.71531    311.71531    23732.883    23732.883    251.50088    251.50088 
   88000   -8413.0628   -8413.0628    -8494.673    -8494.673    315.84003    315.84003    23726.867    23726.867    1339.2858    1339.2858 
Loop time of 99.5173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.644 hours/ns, 10.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.013     | 99.013     | 99.013     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07648    | 0.07648    | 0.07648    |   0.0 |  0.08
Output  | 0.00015391 | 0.00015391 | 0.00015391 |   0.0 |  0.00
Modify  | 0.36999    | 0.36999    | 0.36999    |   0.0 |  0.37
Other   |            | 0.05783    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2954.00 ave        2954 max        2954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116702.0 ave      116702 max      116702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116702
Ave neighs/atom = 58.351000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.961102313801, Press = 1.08717182048516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8413.0628   -8413.0628    -8494.673    -8494.673    315.84003    315.84003    23726.867    23726.867    1339.2858    1339.2858 
   89000   -8417.1682   -8417.1682   -8497.1015   -8497.1015    309.34988    309.34988    23725.211    23725.211    1112.4554    1112.4554 
Loop time of 98.4806 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.356 hours/ns, 10.154 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    | 97.983     | 97.983     | 97.983     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075808   | 0.075808   | 0.075808   |   0.0 |  0.08
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.36437    | 0.36437    | 0.36437    |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2963.00 ave        2963 max        2963 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116814.0 ave      116814 max      116814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116814
Ave neighs/atom = 58.407000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.934653616073, Press = 0.546665750079693
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8417.1682   -8417.1682   -8497.1015   -8497.1015    309.34988    309.34988    23725.211    23725.211    1112.4554    1112.4554 
   90000   -8412.4909   -8412.4909   -8495.6714   -8495.6714      321.917      321.917     23749.91     23749.91   -451.57876   -451.57876 
Loop time of 99.0627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.517 hours/ns, 10.095 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    | 98.563     | 98.563     | 98.563     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076262   | 0.076262   | 0.076262   |   0.0 |  0.08
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.36605    | 0.36605    | 0.36605    |   0.0 |  0.37
Other   |            | 0.0568     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2962.00 ave        2962 max        2962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116718.0 ave      116718 max      116718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116718
Ave neighs/atom = 58.359000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.936691256126, Press = 0.264292025241324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8412.4909   -8412.4909   -8495.6714   -8495.6714      321.917      321.917     23749.91     23749.91   -451.57876   -451.57876 
   91000   -8415.5215   -8415.5215   -8492.9521   -8492.9521    299.66447    299.66447     23753.79     23753.79   -408.81324   -408.81324 
Loop time of 99.1369 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.538 hours/ns, 10.087 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    | 98.634     | 98.634     | 98.634     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076648   | 0.076648   | 0.076648   |   0.0 |  0.08
Output  | 0.00015198 | 0.00015198 | 0.00015198 |   0.0 |  0.00
Modify  | 0.3679     | 0.3679     | 0.3679     |   0.0 |  0.37
Other   |            | 0.05778    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2975.00 ave        2975 max        2975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116788.0 ave      116788 max      116788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0