# 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 5.431230753660202*${_u_distance}
variable latticeconst_converted equal 5.431230753660202*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  5.4312307536602
Lattice spacing in x,y,z = 5.4312308 5.4312308 5.4312308
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 (54.312308 54.312308 54.312308)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (54.312308 54.312308 54.312308)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Si

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

kim interactions Si
#=== BEGIN kim interactions ==================================
pair_style kim Tersoff_LAMMPS_Tersoff_1988T2_Si__MO_245095684871_004
pair_coeff * * Si
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 28.0855

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

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

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

variable temp_converted equal 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_245095684871_004#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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -36740.194   -36740.194   -37043.297   -37043.297       293.15       293.15     160211.9     160211.9    2020.7564    2020.7564 
    1000   -36405.378   -36405.378   -36709.397   -36709.397    294.03539    294.03539    159901.43    159901.43   -270.68744   -270.68744 
Loop time of 51.7367 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.371 hours/ns, 19.329 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    | 51.098     | 51.098     | 51.098     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046143   | 0.046143   | 0.046143   |   0.0 |  0.09
Output  | 0.00027022 | 0.00027022 | 0.00027022 |   0.0 |  0.00
Modify  | 0.5339     | 0.5339     | 0.5339     |   0.0 |  1.03
Other   |            | 0.05811    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4995.00 ave        4995 max        4995 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 28.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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -36405.378   -36405.378   -36709.397   -36709.397    294.03539    294.03539    159901.43    159901.43   -270.68744   -270.68744 
    2000   -36438.476   -36438.476   -36733.405   -36733.405    285.24463    285.24463    159926.12    159926.12   -269.45737   -269.45737 
Loop time of 52.1561 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.657 ns/day, 14.488 hours/ns, 19.173 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    | 51.404     | 51.404     | 51.404     |   0.0 | 98.56
Neigh   | 0.11357    | 0.11357    | 0.11357    |   0.0 |  0.22
Comm    | 0.048196   | 0.048196   | 0.048196   |   0.0 |  0.09
Output  | 0.00015486 | 0.00015486 | 0.00015486 |   0.0 |  0.00
Modify  | 0.53363    | 0.53363    | 0.53363    |   0.0 |  1.02
Other   |            | 0.05671    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5026.00 ave        5026 max        5026 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226672.0 ave      226672 max      226672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226672
Ave neighs/atom = 28.334000
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -36438.476   -36438.476   -36733.405   -36733.405    285.24463    285.24463    159926.12    159926.12   -269.45737   -269.45737 
    3000   -36416.797   -36416.797   -36731.899   -36731.899    304.75496    304.75496    160268.69    160268.69    -2148.955    -2148.955 
Loop time of 51.8071 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.391 hours/ns, 19.302 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    | 51.174     | 51.174     | 51.174     |   0.0 | 98.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045671   | 0.045671   | 0.045671   |   0.0 |  0.09
Output  | 0.00015025 | 0.00015025 | 0.00015025 |   0.0 |  0.00
Modify  | 0.53084    | 0.53084    | 0.53084    |   0.0 |  1.02
Other   |            | 0.05679    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226950.0 ave      226950 max      226950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226950
Ave neighs/atom = 28.368750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -36416.797   -36416.797   -36731.899   -36731.899    304.75496    304.75496    160268.69    160268.69    -2148.955    -2148.955 
    4000   -36431.126   -36431.126   -36735.746   -36735.746    294.61706    294.61706    160196.54    160196.54   -1457.2776   -1457.2776 
Loop time of 51.9598 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.663 ns/day, 14.433 hours/ns, 19.246 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    | 51.248     | 51.248     | 51.248     |   0.0 | 98.63
Neigh   | 0.075926   | 0.075926   | 0.075926   |   0.0 |  0.15
Comm    | 0.048344   | 0.048344   | 0.048344   |   0.0 |  0.09
Output  | 0.00015082 | 0.00015082 | 0.00015082 |   0.0 |  0.00
Modify  | 0.53059    | 0.53059    | 0.53059    |   0.0 |  1.02
Other   |            | 0.0563     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5064.00 ave        5064 max        5064 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227118.0 ave      227118 max      227118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227118
Ave neighs/atom = 28.389750
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -36431.126   -36431.126   -36735.746   -36735.746    294.61706    294.61706    160196.54    160196.54   -1457.2776   -1457.2776 
    5000   -36417.165   -36417.165   -36732.633   -36732.633    305.10885    305.10885    159908.07    159908.07    163.50671    163.50671 
Loop time of 51.7827 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.384 hours/ns, 19.311 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    | 51.149     | 51.149     | 51.149     |   0.0 | 98.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045473   | 0.045473   | 0.045473   |   0.0 |  0.09
Output  | 0.00011868 | 0.00011868 | 0.00011868 |   0.0 |  0.00
Modify  | 0.53139    | 0.53139    | 0.53139    |   0.0 |  1.03
Other   |            | 0.05652    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5032.00 ave        5032 max        5032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226374.0 ave      226374 max      226374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226374
Ave neighs/atom = 28.296750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 303.26364613829, Press = -601.904140321964
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -36417.165   -36417.165   -36732.633   -36732.633    305.10885    305.10885    159908.07    159908.07    163.50671    163.50671 
    6000   -36432.884   -36432.884   -36730.209   -36730.209    287.56119    287.56119    159564.77    159564.77    1660.7338    1660.7338 
Loop time of 51.813 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.393 hours/ns, 19.300 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    | 51.168     | 51.168     | 51.168     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045591   | 0.045591   | 0.045591   |   0.0 |  0.09
Output  | 0.00012282 | 0.00012282 | 0.00012282 |   0.0 |  0.00
Modify  | 0.54222    | 0.54222    | 0.54222    |   0.0 |  1.05
Other   |            | 0.05677    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5032.00 ave        5032 max        5032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226568.0 ave      226568 max      226568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226568
Ave neighs/atom = 28.321000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.70296801467, Press = -52.1342822540012
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -36432.884   -36432.884   -36730.209   -36730.209    287.56119    287.56119    159564.77    159564.77    1660.7338    1660.7338 
    7000   -36423.618   -36423.618   -36726.443   -36726.443    292.88114    292.88114    159924.82    159924.82   -359.83799   -359.83799 
Loop time of 51.904 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.665 ns/day, 14.418 hours/ns, 19.266 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    | 51.221     | 51.221     | 51.221     |   0.0 | 98.68
Neigh   | 0.03737    | 0.03737    | 0.03737    |   0.0 |  0.07
Comm    | 0.046761   | 0.046761   | 0.046761   |   0.0 |  0.09
Output  | 0.00012093 | 0.00012093 | 0.00012093 |   0.0 |  0.00
Modify  | 0.54218    | 0.54218    | 0.54218    |   0.0 |  1.04
Other   |            | 0.05651    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5021.00 ave        5021 max        5021 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226708.0 ave      226708 max      226708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226708
Ave neighs/atom = 28.338500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42814743146, Press = -12.8774241812284
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -36423.618   -36423.618   -36726.443   -36726.443    292.88114    292.88114    159924.82    159924.82   -359.83799   -359.83799 
    8000   -36429.663   -36429.663   -36735.534   -36735.534    295.82682    295.82682    160099.65    160099.65   -781.01246   -781.01246 
Loop time of 52.0985 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.658 ns/day, 14.472 hours/ns, 19.194 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    | 51.375     | 51.375     | 51.375     |   0.0 | 98.61
Neigh   | 0.077228   | 0.077228   | 0.077228   |   0.0 |  0.15
Comm    | 0.047935   | 0.047935   | 0.047935   |   0.0 |  0.09
Output  | 0.00012289 | 0.00012289 | 0.00012289 |   0.0 |  0.00
Modify  | 0.54164    | 0.54164    | 0.54164    |   0.0 |  1.04
Other   |            | 0.05681    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5053.00 ave        5053 max        5053 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226994.0 ave      226994 max      226994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226994
Ave neighs/atom = 28.374250
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.333107959207, Press = -10.6889057416917
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -36429.663   -36429.663   -36735.534   -36735.534    295.82682    295.82682    160099.65    160099.65   -781.01246   -781.01246 
    9000   -36422.578   -36422.578   -36727.978   -36727.978    295.37188    295.37188    159888.11    159888.11   -103.73207   -103.73207 
Loop time of 51.7545 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.376 hours/ns, 19.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.115     | 51.115     | 51.115     |   0.0 | 98.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044235   | 0.044235   | 0.044235   |   0.0 |  0.09
Output  | 0.00011614 | 0.00011614 | 0.00011614 |   0.0 |  0.00
Modify  | 0.53805    | 0.53805    | 0.53805    |   0.0 |  1.04
Other   |            | 0.0569     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5015.00 ave        5015 max        5015 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226248.0 ave      226248 max      226248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226248
Ave neighs/atom = 28.281000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.348083606752, Press = -11.5668199627826
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -36422.578   -36422.578   -36727.978   -36727.978    295.37188    295.37188    159888.11    159888.11   -103.73207   -103.73207 
   10000   -36428.304   -36428.304   -36734.199   -36734.199    295.85034    295.85034    159912.11    159912.11    54.220059    54.220059 
Loop time of 51.8934 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.665 ns/day, 14.415 hours/ns, 19.270 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    | 51.215     | 51.215     | 51.215     |   0.0 | 98.69
Neigh   | 0.037847   | 0.037847   | 0.037847   |   0.0 |  0.07
Comm    | 0.046729   | 0.046729   | 0.046729   |   0.0 |  0.09
Output  | 9.0888e-05 | 9.0888e-05 | 9.0888e-05 |   0.0 |  0.00
Modify  | 0.53727    | 0.53727    | 0.53727    |   0.0 |  1.04
Other   |            | 0.05668    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5032.00 ave        5032 max        5032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226690.0 ave      226690 max      226690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226690
Ave neighs/atom = 28.336250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.269990537339, Press = -9.24692182238319
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -36428.304   -36428.304   -36734.199   -36734.199    295.85034    295.85034    159912.11    159912.11    54.220059    54.220059 
   11000   -36424.803   -36424.803    -36726.46    -36726.46    291.75129    291.75129    159879.24    159879.24    289.95026    289.95026 
Loop time of 51.7816 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.384 hours/ns, 19.312 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    | 51.142     | 51.142     | 51.142     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044627   | 0.044627   | 0.044627   |   0.0 |  0.09
Output  | 0.00011651 | 0.00011651 | 0.00011651 |   0.0 |  0.00
Modify  | 0.53748    | 0.53748    | 0.53748    |   0.0 |  1.04
Other   |            | 0.05696    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5044.00 ave        5044 max        5044 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226886.0 ave      226886 max      226886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226886
Ave neighs/atom = 28.360750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154382924755, Press = -6.88680489439529
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -36424.803   -36424.803    -36726.46    -36726.46    291.75129    291.75129    159879.24    159879.24    289.95026    289.95026 
   12000   -36425.472   -36425.472    -36730.43    -36730.43    294.94394    294.94394    160095.17    160095.17   -1302.2053   -1302.2053 
Loop time of 52.4096 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.649 ns/day, 14.558 hours/ns, 19.080 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    | 51.679     | 51.679     | 51.679     |   0.0 | 98.61
Neigh   | 0.075805   | 0.075805   | 0.075805   |   0.0 |  0.14
Comm    | 0.047276   | 0.047276   | 0.047276   |   0.0 |  0.09
Output  | 0.00012016 | 0.00012016 | 0.00012016 |   0.0 |  0.00
Modify  | 0.54709    | 0.54709    | 0.54709    |   0.0 |  1.04
Other   |            | 0.06007    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5059.00 ave        5059 max        5059 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227124.0 ave      227124 max      227124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227124
Ave neighs/atom = 28.390500
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.198468045242, Press = -1.77053477647579
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -36425.472   -36425.472    -36730.43    -36730.43    294.94394    294.94394    160095.17    160095.17   -1302.2053   -1302.2053 
   13000   -36428.533   -36428.533   -36736.379   -36736.379    297.73689    297.73689    159902.23    159902.23   -163.26071   -163.26071 
Loop time of 52.9436 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.632 ns/day, 14.707 hours/ns, 18.888 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    | 52.239     | 52.239     | 52.239     |   0.0 | 98.67
Neigh   | 0.037765   | 0.037765   | 0.037765   |   0.0 |  0.07
Comm    | 0.047855   | 0.047855   | 0.047855   |   0.0 |  0.09
Output  | 0.00012106 | 0.00012106 | 0.00012106 |   0.0 |  0.00
Modify  | 0.55691    | 0.55691    | 0.55691    |   0.0 |  1.05
Other   |            | 0.06233    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5050.00 ave        5050 max        5050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226912.0 ave      226912 max      226912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226912
Ave neighs/atom = 28.364000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.289493901335, Press = -6.03116344936607
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -36428.533   -36428.533   -36736.379   -36736.379    297.73689    297.73689    159902.23    159902.23   -163.26071   -163.26071 
   14000   -36418.293   -36418.293   -36724.877   -36724.877    296.51601    296.51601    159854.27    159854.27   -192.47029   -192.47029 
Loop time of 52.5933 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.643 ns/day, 14.609 hours/ns, 19.014 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    | 51.932     | 51.932     | 51.932     |   0.0 | 98.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045259   | 0.045259   | 0.045259   |   0.0 |  0.09
Output  | 0.00011813 | 0.00011813 | 0.00011813 |   0.0 |  0.00
Modify  | 0.5534     | 0.5534     | 0.5534     |   0.0 |  1.05
Other   |            | 0.0621     |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5049.00 ave        5049 max        5049 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226680.0 ave      226680 max      226680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226680
Ave neighs/atom = 28.335000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.387709594285, Press = -6.06642141483988
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -36418.293   -36418.293   -36724.877   -36724.877    296.51601    296.51601    159854.27    159854.27   -192.47029   -192.47029 
   15000   -36437.294   -36437.294   -36735.207   -36735.207    288.13106    288.13106    159840.94    159840.94      271.917      271.917 
Loop time of 52.881 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.634 ns/day, 14.689 hours/ns, 18.910 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 52.175     | 52.175     | 52.175     |   0.0 | 98.66
Neigh   | 0.037917   | 0.037917   | 0.037917   |   0.0 |  0.07
Comm    | 0.047496   | 0.047496   | 0.047496   |   0.0 |  0.09
Output  | 0.00012062 | 0.00012062 | 0.00012062 |   0.0 |  0.00
Modify  | 0.55703    | 0.55703    | 0.55703    |   0.0 |  1.05
Other   |            | 0.06391    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226744.0 ave      226744 max      226744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226744
Ave neighs/atom = 28.343000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.289945289677, Press = -3.89427236278516
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -36437.294   -36437.294   -36735.207   -36735.207    288.13106    288.13106    159840.94    159840.94      271.917      271.917 
   16000   -36428.079   -36428.079   -36735.272   -36735.272    297.10531    297.10531    159972.86    159972.86   -586.12399   -586.12399 
Loop time of 52.9597 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.631 ns/day, 14.711 hours/ns, 18.882 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    | 52.25      | 52.25      | 52.25      |   0.0 | 98.66
Neigh   | 0.037678   | 0.037678   | 0.037678   |   0.0 |  0.07
Comm    | 0.047806   | 0.047806   | 0.047806   |   0.0 |  0.09
Output  | 0.00020003 | 0.00020003 | 0.00020003 |   0.0 |  0.00
Modify  | 0.55848    | 0.55848    | 0.55848    |   0.0 |  1.05
Other   |            | 0.06594    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5052.00 ave        5052 max        5052 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226784.0 ave      226784 max      226784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226784
Ave neighs/atom = 28.348000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.22526633747, Press = -3.69528787534312
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -36428.079   -36428.079   -36735.272   -36735.272    297.10531    297.10531    159972.86    159972.86   -586.12399   -586.12399 
   17000   -36433.344   -36433.344   -36732.983   -36732.983     289.7993     289.7993    160017.65    160017.65   -797.38894   -797.38894 
Loop time of 52.937 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.632 ns/day, 14.705 hours/ns, 18.890 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    | 52.228     | 52.228     | 52.228     |   0.0 | 98.66
Neigh   | 0.04124    | 0.04124    | 0.04124    |   0.0 |  0.08
Comm    | 0.047691   | 0.047691   | 0.047691   |   0.0 |  0.09
Output  | 0.00013063 | 0.00013063 | 0.00013063 |   0.0 |  0.00
Modify  | 0.55713    | 0.55713    | 0.55713    |   0.0 |  1.05
Other   |            | 0.06291    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5025.00 ave        5025 max        5025 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226802.0 ave      226802 max      226802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226802
Ave neighs/atom = 28.350250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25113383954, Press = -4.64297441880744
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -36433.344   -36433.344   -36732.983   -36732.983     289.7993     289.7993    160017.65    160017.65   -797.38894   -797.38894 
   18000   -36421.509   -36421.509   -36727.429   -36727.429    295.87395    295.87395    159899.38    159899.38   -122.46259   -122.46259 
Loop time of 52.8049 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.636 ns/day, 14.668 hours/ns, 18.938 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    | 52.14      | 52.14      | 52.14      |   0.0 | 98.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045502   | 0.045502   | 0.045502   |   0.0 |  0.09
Output  | 0.0001222  | 0.0001222  | 0.0001222  |   0.0 |  0.00
Modify  | 0.55585    | 0.55585    | 0.55585    |   0.0 |  1.05
Other   |            | 0.0631     |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5054.00 ave        5054 max        5054 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226836.0 ave      226836 max      226836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226836
Ave neighs/atom = 28.354500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.230163776695, Press = -3.19089471227989
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -36421.509   -36421.509   -36727.429   -36727.429    295.87395    295.87395    159899.38    159899.38   -122.46259   -122.46259 
   19000   -36428.129   -36428.129   -36730.935   -36730.935    292.86351    292.86351    159842.44    159842.44   -50.708519   -50.708519 
Loop time of 53.1775 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.625 ns/day, 14.772 hours/ns, 18.805 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    | 52.39      | 52.39      | 52.39      |   0.0 | 98.52
Neigh   | 0.11318    | 0.11318    | 0.11318    |   0.0 |  0.21
Comm    | 0.048673   | 0.048673   | 0.048673   |   0.0 |  0.09
Output  | 0.00020149 | 0.00020149 | 0.00020149 |   0.0 |  0.00
Modify  | 0.56082    | 0.56082    | 0.56082    |   0.0 |  1.05
Other   |            | 0.06446    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5051.00 ave        5051 max        5051 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226792.0 ave      226792 max      226792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226792
Ave neighs/atom = 28.349000
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.273298372757, Press = -3.0069605454224
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -36428.129   -36428.129   -36730.935   -36730.935    292.86351    292.86351    159842.44    159842.44   -50.708519   -50.708519 
   20000   -36427.891   -36427.891   -36728.444   -36728.444    290.68329    290.68329    159724.01    159724.01    905.53803    905.53803 
Loop time of 52.1277 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.657 ns/day, 14.480 hours/ns, 19.184 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    | 51.44      | 51.44      | 51.44      |   0.0 | 98.68
Neigh   | 0.037352   | 0.037352   | 0.037352   |   0.0 |  0.07
Comm    | 0.046581   | 0.046581   | 0.046581   |   0.0 |  0.09
Output  | 0.00010987 | 0.00010987 | 0.00010987 |   0.0 |  0.00
Modify  | 0.54343    | 0.54343    | 0.54343    |   0.0 |  1.04
Other   |            | 0.0605     |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5043.00 ave        5043 max        5043 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226956.0 ave      226956 max      226956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226956
Ave neighs/atom = 28.369500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.245664014239, Press = -3.57679179629781
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -36427.891   -36427.891   -36728.444   -36728.444    290.68329    290.68329    159724.01    159724.01    905.53803    905.53803 
   21000   -36425.806   -36425.806    -36733.52    -36733.52    297.60889    297.60889    159869.65    159869.65    139.27216    139.27216 
Loop time of 51.7897 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.386 hours/ns, 19.309 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    | 51.112     | 51.112     | 51.112     |   0.0 | 98.69
Neigh   | 0.03781    | 0.03781    | 0.03781    |   0.0 |  0.07
Comm    | 0.046541   | 0.046541   | 0.046541   |   0.0 |  0.09
Output  | 0.00011162 | 0.00011162 | 0.00011162 |   0.0 |  0.00
Modify  | 0.53588    | 0.53588    | 0.53588    |   0.0 |  1.03
Other   |            | 0.05745    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226914.0 ave      226914 max      226914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226914
Ave neighs/atom = 28.364250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.237408481476, Press = -1.3027916948009
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -36425.806   -36425.806    -36733.52    -36733.52    297.60889    297.60889    159869.65    159869.65    139.27216    139.27216 
   22000   -36429.453   -36429.453    -36729.92    -36729.92    290.60103    290.60103    159746.14    159746.14    684.40772    684.40772 
Loop time of 51.6867 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.357 hours/ns, 19.347 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    | 51.049     | 51.049     | 51.049     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044376   | 0.044376   | 0.044376   |   0.0 |  0.09
Output  | 0.00011372 | 0.00011372 | 0.00011372 |   0.0 |  0.00
Modify  | 0.53544    | 0.53544    | 0.53544    |   0.0 |  1.04
Other   |            | 0.05728    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5055.00 ave        5055 max        5055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226854.0 ave      226854 max      226854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226854
Ave neighs/atom = 28.356750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.24246930295, Press = -2.87527443768076
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -36429.453   -36429.453    -36729.92    -36729.92    290.60103    290.60103    159746.14    159746.14    684.40772    684.40772 
   23000   -36424.383   -36424.383   -36729.829   -36729.829    295.41532    295.41532    159683.11    159683.11    955.79475    955.79475 
Loop time of 51.8421 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.401 hours/ns, 19.289 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    | 51.127     | 51.127     | 51.127     |   0.0 | 98.62
Neigh   | 0.075457   | 0.075457   | 0.075457   |   0.0 |  0.15
Comm    | 0.046554   | 0.046554   | 0.046554   |   0.0 |  0.09
Output  | 0.00011485 | 0.00011485 | 0.00011485 |   0.0 |  0.00
Modify  | 0.53589    | 0.53589    | 0.53589    |   0.0 |  1.03
Other   |            | 0.05686    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5030.00 ave        5030 max        5030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226704.0 ave      226704 max      226704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226704
Ave neighs/atom = 28.338000
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.247739593527, Press = -2.17060206881918
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -36424.383   -36424.383   -36729.829   -36729.829    295.41532    295.41532    159683.11    159683.11    955.79475    955.79475 
   24000   -36439.299   -36439.299   -36735.444   -36735.444    286.42006    286.42006    159820.88    159820.88     178.3399     178.3399 
Loop time of 51.8186 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.394 hours/ns, 19.298 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    | 51.142     | 51.142     | 51.142     |   0.0 | 98.69
Neigh   | 0.037616   | 0.037616   | 0.037616   |   0.0 |  0.07
Comm    | 0.046011   | 0.046011   | 0.046011   |   0.0 |  0.09
Output  | 0.00011459 | 0.00011459 | 0.00011459 |   0.0 |  0.00
Modify  | 0.53576    | 0.53576    | 0.53576    |   0.0 |  1.03
Other   |            | 0.05706    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5063.00 ave        5063 max        5063 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227018.0 ave      227018 max      227018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227018
Ave neighs/atom = 28.377250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.164365708733, Press = -1.7284446632728
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -36439.299   -36439.299   -36735.444   -36735.444    286.42006    286.42006    159820.88    159820.88     178.3399     178.3399 
   25000   -36421.082   -36421.082   -36728.051   -36728.051    296.88936    296.88936    160004.31    160004.31   -766.47102   -766.47102 
Loop time of 51.7193 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.366 hours/ns, 19.335 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    | 51.082     | 51.082     | 51.082     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044298   | 0.044298   | 0.044298   |   0.0 |  0.09
Output  | 0.00011083 | 0.00011083 | 0.00011083 |   0.0 |  0.00
Modify  | 0.53579    | 0.53579    | 0.53579    |   0.0 |  1.04
Other   |            | 0.05724    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5048.00 ave        5048 max        5048 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226916.0 ave      226916 max      226916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226916
Ave neighs/atom = 28.364500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.168595144374, Press = -2.59938681380945
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -36421.082   -36421.082   -36728.051   -36728.051    296.88936    296.88936    160004.31    160004.31   -766.47102   -766.47102 
   26000   -36423.443   -36423.443    -36727.09    -36727.09    293.67694    293.67694    159775.32    159775.32    535.66621    535.66621 
Loop time of 51.8247 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.396 hours/ns, 19.296 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    | 51.148     | 51.148     | 51.148     |   0.0 | 98.69
Neigh   | 0.037922   | 0.037922   | 0.037922   |   0.0 |  0.07
Comm    | 0.046319   | 0.046319   | 0.046319   |   0.0 |  0.09
Output  | 0.00010623 | 0.00010623 | 0.00010623 |   0.0 |  0.00
Modify  | 0.53541    | 0.53541    | 0.53541    |   0.0 |  1.03
Other   |            | 0.05693    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5032.00 ave        5032 max        5032 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226718.0 ave      226718 max      226718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226718
Ave neighs/atom = 28.339750
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.179249511195, Press = -2.0901486109273
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -36423.443   -36423.443    -36727.09    -36727.09    293.67694    293.67694    159775.32    159775.32    535.66621    535.66621 
   27000   -36431.347   -36431.347   -36733.566   -36733.566    292.29536    292.29536     159929.6     159929.6   -476.55694   -476.55694 
Loop time of 51.728 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.369 hours/ns, 19.332 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    | 51.091     | 51.091     | 51.091     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044107   | 0.044107   | 0.044107   |   0.0 |  0.09
Output  | 0.00012014 | 0.00012014 | 0.00012014 |   0.0 |  0.00
Modify  | 0.53555    | 0.53555    | 0.53555    |   0.0 |  1.04
Other   |            | 0.05738    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226950.0 ave      226950 max      226950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226950
Ave neighs/atom = 28.368750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.171981741782, Press = -1.53304898358859
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -36431.347   -36431.347   -36733.566   -36733.566    292.29536    292.29536     159929.6     159929.6   -476.55694   -476.55694 
   28000   -36429.725   -36429.725    -36732.34    -36732.34    292.67777    292.67777    159847.31    159847.31    74.623211    74.623211 
Loop time of 51.6772 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.355 hours/ns, 19.351 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    | 51.04      | 51.04      | 51.04      |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044308   | 0.044308   | 0.044308   |   0.0 |  0.09
Output  | 0.00011614 | 0.00011614 | 0.00011614 |   0.0 |  0.00
Modify  | 0.53546    | 0.53546    | 0.53546    |   0.0 |  1.04
Other   |            | 0.05716    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226868.0 ave      226868 max      226868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226868
Ave neighs/atom = 28.358500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.191170431908, Press = -1.96197648843539
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -36429.725   -36429.725    -36732.34    -36732.34    292.67777    292.67777    159847.31    159847.31    74.623211    74.623211 
   29000   -36426.714   -36426.714   -36730.403   -36730.403    293.71624    293.71624    159911.88    159911.88   -211.96023   -211.96023 
Loop time of 51.7864 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.385 hours/ns, 19.310 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    | 51.11      | 51.11      | 51.11      |   0.0 | 98.69
Neigh   | 0.03763    | 0.03763    | 0.03763    |   0.0 |  0.07
Comm    | 0.046308   | 0.046308   | 0.046308   |   0.0 |  0.09
Output  | 0.00011675 | 0.00011675 | 0.00011675 |   0.0 |  0.00
Modify  | 0.53508    | 0.53508    | 0.53508    |   0.0 |  1.03
Other   |            | 0.05694    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5049.00 ave        5049 max        5049 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226934.0 ave      226934 max      226934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226934
Ave neighs/atom = 28.366750
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.14789460454, Press = -2.0115666454709
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -36426.714   -36426.714   -36730.403   -36730.403    293.71624    293.71624    159911.88    159911.88   -211.96023   -211.96023 
   30000     -36433.1     -36433.1   -36733.423   -36733.423    290.46113    290.46113    159810.08    159810.08    198.24971    198.24971 
Loop time of 51.7313 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.370 hours/ns, 19.331 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    | 51.056     | 51.056     | 51.056     |   0.0 | 98.69
Neigh   | 0.037339   | 0.037339   | 0.037339   |   0.0 |  0.07
Comm    | 0.045729   | 0.045729   | 0.045729   |   0.0 |  0.09
Output  | 0.0001146  | 0.0001146  | 0.0001146  |   0.0 |  0.00
Modify  | 0.53506    | 0.53506    | 0.53506    |   0.0 |  1.03
Other   |            | 0.05691    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226808.0 ave      226808 max      226808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226808
Ave neighs/atom = 28.351000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.117257168221, Press = -1.5089994389371
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000     -36433.1     -36433.1   -36733.423   -36733.423    290.46113    290.46113    159810.08    159810.08    198.24971    198.24971 
   31000   -36420.583   -36420.583   -36729.205   -36729.205    298.48801    298.48801    159826.54    159826.54    399.61967    399.61967 
Loop time of 51.6618 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.351 hours/ns, 19.357 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    | 51.025     | 51.025     | 51.025     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044516   | 0.044516   | 0.044516   |   0.0 |  0.09
Output  | 0.00011209 | 0.00011209 | 0.00011209 |   0.0 |  0.00
Modify  | 0.53499    | 0.53499    | 0.53499    |   0.0 |  1.04
Other   |            | 0.05728    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226828.0 ave      226828 max      226828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226828
Ave neighs/atom = 28.353500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.126317469359, Press = -1.25362263940823
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -36420.583   -36420.583   -36729.205   -36729.205    298.48801    298.48801    159826.54    159826.54    399.61967    399.61967 
   32000   -36431.074   -36431.074   -36730.464   -36730.464    289.55856    289.55856    159859.45    159859.45   -153.95963   -153.95963 
Loop time of 51.785 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.385 hours/ns, 19.311 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    | 51.109     | 51.109     | 51.109     |   0.0 | 98.69
Neigh   | 0.037626   | 0.037626   | 0.037626   |   0.0 |  0.07
Comm    | 0.046437   | 0.046437   | 0.046437   |   0.0 |  0.09
Output  | 0.00011497 | 0.00011497 | 0.00011497 |   0.0 |  0.00
Modify  | 0.53495    | 0.53495    | 0.53495    |   0.0 |  1.03
Other   |            | 0.05699    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5048.00 ave        5048 max        5048 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227088.0 ave      227088 max      227088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227088
Ave neighs/atom = 28.386000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.141202949004, Press = -0.850927603951882
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -36431.074   -36431.074   -36730.464   -36730.464    289.55856    289.55856    159859.45    159859.45   -153.95963   -153.95963 
   33000   -36419.899   -36419.899   -36727.812   -36727.812    297.80201    297.80201    159977.79    159977.79   -626.78203   -626.78203 
Loop time of 51.7236 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.368 hours/ns, 19.334 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    | 51.086     | 51.086     | 51.086     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044306   | 0.044306   | 0.044306   |   0.0 |  0.09
Output  | 0.00010461 | 0.00010461 | 0.00010461 |   0.0 |  0.00
Modify  | 0.53549    | 0.53549    | 0.53549    |   0.0 |  1.04
Other   |            | 0.05721    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227018.0 ave      227018 max      227018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227018
Ave neighs/atom = 28.377250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.146366187153, Press = -1.05356317618495
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -36419.899   -36419.899   -36727.812   -36727.812    297.80201    297.80201    159977.79    159977.79   -626.78203   -626.78203 
   34000   -36424.459   -36424.459   -36728.355   -36728.355    293.91754    293.91754    159811.57    159811.57    269.63942    269.63942 
Loop time of 51.72 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.367 hours/ns, 19.335 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    | 51.083     | 51.083     | 51.083     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044209   | 0.044209   | 0.044209   |   0.0 |  0.09
Output  | 8.838e-05  | 8.838e-05  | 8.838e-05  |   0.0 |  0.00
Modify  | 0.53523    | 0.53523    | 0.53523    |   0.0 |  1.03
Other   |            | 0.057      |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226986.0 ave      226986 max      226986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226986
Ave neighs/atom = 28.373250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.136663695931, Press = -1.47985559426202
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -36424.459   -36424.459   -36728.355   -36728.355    293.91754    293.91754    159811.57    159811.57    269.63942    269.63942 
   35000   -36427.616   -36427.616    -36729.32    -36729.32    291.79678    291.79678    159833.81    159833.81    144.38516    144.38516 
Loop time of 51.7907 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.386 hours/ns, 19.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.115     | 51.115     | 51.115     |   0.0 | 98.69
Neigh   | 0.037521   | 0.037521   | 0.037521   |   0.0 |  0.07
Comm    | 0.045788   | 0.045788   | 0.045788   |   0.0 |  0.09
Output  | 0.00011261 | 0.00011261 | 0.00011261 |   0.0 |  0.00
Modify  | 0.53537    | 0.53537    | 0.53537    |   0.0 |  1.03
Other   |            | 0.05718    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226816.0 ave      226816 max      226816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226816
Ave neighs/atom = 28.352000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.117468883196, Press = -2.66496556537384
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -36427.616   -36427.616    -36729.32    -36729.32    291.79678    291.79678    159833.81    159833.81    144.38516    144.38516 
   36000   -36425.365   -36425.365   -36729.995   -36729.995     294.6267     294.6267     159809.8     159809.8    93.403119    93.403119 
Loop time of 51.705 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.362 hours/ns, 19.340 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    | 51.068     | 51.068     | 51.068     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044255   | 0.044255   | 0.044255   |   0.0 |  0.09
Output  | 0.00011206 | 0.00011206 | 0.00011206 |   0.0 |  0.00
Modify  | 0.53556    | 0.53556    | 0.53556    |   0.0 |  1.04
Other   |            | 0.05722    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5041.00 ave        5041 max        5041 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227052.0 ave      227052 max      227052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227052
Ave neighs/atom = 28.381500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.100188148538, Press = -1.99993675699743
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -36425.365   -36425.365   -36729.995   -36729.995     294.6267     294.6267     159809.8     159809.8    93.403119    93.403119 
   37000   -36430.335   -36430.335   -36732.889   -36732.889    292.61911    292.61911    159858.47    159858.47    -252.3285    -252.3285 
Loop time of 51.7216 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.367 hours/ns, 19.334 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    | 51.085     | 51.085     | 51.085     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044141   | 0.044141   | 0.044141   |   0.0 |  0.09
Output  | 0.00010824 | 0.00010824 | 0.00010824 |   0.0 |  0.00
Modify  | 0.53521    | 0.53521    | 0.53521    |   0.0 |  1.03
Other   |            | 0.057      |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5043.00 ave        5043 max        5043 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227056.0 ave      227056 max      227056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227056
Ave neighs/atom = 28.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 = 293.10908246056, Press = -1.39204985733793
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -36430.335   -36430.335   -36732.889   -36732.889    292.61911    292.61911    159858.47    159858.47    -252.3285    -252.3285 
   38000   -36424.486   -36424.486   -36729.362   -36729.362    294.86443    294.86443    159965.08    159965.08   -674.94066   -674.94066 
Loop time of 51.795 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.388 hours/ns, 19.307 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    | 51.119     | 51.119     | 51.119     |   0.0 | 98.70
Neigh   | 0.037567   | 0.037567   | 0.037567   |   0.0 |  0.07
Comm    | 0.045827   | 0.045827   | 0.045827   |   0.0 |  0.09
Output  | 0.00011825 | 0.00011825 | 0.00011825 |   0.0 |  0.00
Modify  | 0.53522    | 0.53522    | 0.53522    |   0.0 |  1.03
Other   |            | 0.05688    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5050.00 ave        5050 max        5050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226992.0 ave      226992 max      226992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226992
Ave neighs/atom = 28.374000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.104229902969, Press = -1.89667773092861
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -36424.486   -36424.486   -36729.362   -36729.362    294.86443    294.86443    159965.08    159965.08   -674.94066   -674.94066 
   39000   -36428.692   -36428.692    -36728.38    -36728.38    289.84622    289.84622    159713.79    159713.79    976.98004    976.98004 
Loop time of 51.8024 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.390 hours/ns, 19.304 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    | 51.126     | 51.126     | 51.126     |   0.0 | 98.69
Neigh   | 0.037547   | 0.037547   | 0.037547   |   0.0 |  0.07
Comm    | 0.046533   | 0.046533   | 0.046533   |   0.0 |  0.09
Output  | 0.00011445 | 0.00011445 | 0.00011445 |   0.0 |  0.00
Modify  | 0.53529    | 0.53529    | 0.53529    |   0.0 |  1.03
Other   |            | 0.05691    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226930.0 ave      226930 max      226930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226930
Ave neighs/atom = 28.366250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.122607768143, Press = -1.18637366452098
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -36428.692   -36428.692    -36728.38    -36728.38    289.84622    289.84622    159713.79    159713.79    976.98004    976.98004 
   40000    -36425.28    -36425.28   -36729.365   -36729.365    294.09978    294.09978    159853.65    159853.65   -66.770577   -66.770577 
Loop time of 51.9301 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.664 ns/day, 14.425 hours/ns, 19.257 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    | 51.141     | 51.141     | 51.141     |   0.0 | 98.48
Neigh   | 0.15033    | 0.15033    | 0.15033    |   0.0 |  0.29
Comm    | 0.047045   | 0.047045   | 0.047045   |   0.0 |  0.09
Output  | 0.00010678 | 0.00010678 | 0.00010678 |   0.0 |  0.00
Modify  | 0.53544    | 0.53544    | 0.53544    |   0.0 |  1.03
Other   |            | 0.05619    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5051.00 ave        5051 max        5051 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226936.0 ave      226936 max      226936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226936
Ave neighs/atom = 28.367000
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165835358062, Press = -1.54191784407356
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000    -36425.28    -36425.28   -36729.365   -36729.365    294.09978    294.09978    159853.65    159853.65   -66.770577   -66.770577 
   41000   -36423.164   -36423.164   -36726.005   -36726.005      292.897      292.897    159882.38    159882.38    3.5170795    3.5170795 
Loop time of 51.8317 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.398 hours/ns, 19.293 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    | 51.118     | 51.118     | 51.118     |   0.0 | 98.62
Neigh   | 0.074923   | 0.074923   | 0.074923   |   0.0 |  0.14
Comm    | 0.046984   | 0.046984   | 0.046984   |   0.0 |  0.09
Output  | 9.0507e-05 | 9.0507e-05 | 9.0507e-05 |   0.0 |  0.00
Modify  | 0.53524    | 0.53524    | 0.53524    |   0.0 |  1.03
Other   |            | 0.05654    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5048.00 ave        5048 max        5048 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227014.0 ave      227014 max      227014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227014
Ave neighs/atom = 28.376750
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.174276511201, Press = -1.0814957950269
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -36423.164   -36423.164   -36726.005   -36726.005      292.897      292.897    159882.38    159882.38    3.5170795    3.5170795 
   42000   -36429.823   -36429.823   -36730.748   -36730.748    291.04395    291.04395    159965.16    159965.16   -669.55788   -669.55788 
Loop time of 51.8586 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.666 ns/day, 14.405 hours/ns, 19.283 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    | 51.145     | 51.145     | 51.145     |   0.0 | 98.62
Neigh   | 0.07537    | 0.07537    | 0.07537    |   0.0 |  0.15
Comm    | 0.046204   | 0.046204   | 0.046204   |   0.0 |  0.09
Output  | 0.00011062 | 0.00011062 | 0.00011062 |   0.0 |  0.00
Modify  | 0.53534    | 0.53534    | 0.53534    |   0.0 |  1.03
Other   |            | 0.0568     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5042.00 ave        5042 max        5042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227038.0 ave      227038 max      227038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227038
Ave neighs/atom = 28.379750
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.214305861158, Press = -1.75766411531529
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -36429.823   -36429.823   -36730.748   -36730.748    291.04395    291.04395    159965.16    159965.16   -669.55788   -669.55788 
   43000   -36426.607   -36426.607    -36729.35    -36729.35    292.80173    292.80173    159773.73    159773.73    387.23428    387.23428 
Loop time of 51.7028 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.362 hours/ns, 19.341 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    | 51.066     | 51.066     | 51.066     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044248   | 0.044248   | 0.044248   |   0.0 |  0.09
Output  | 0.00011102 | 0.00011102 | 0.00011102 |   0.0 |  0.00
Modify  | 0.53546    | 0.53546    | 0.53546    |   0.0 |  1.04
Other   |            | 0.05706    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5044.00 ave        5044 max        5044 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226872.0 ave      226872 max      226872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226872
Ave neighs/atom = 28.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 = 293.208528353099, Press = -2.1883040918048
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -36426.607   -36426.607    -36729.35    -36729.35    292.80173    292.80173    159773.73    159773.73    387.23428    387.23428 
   44000   -36427.843   -36427.843   -36732.377   -36732.377    294.53368    294.53368    159701.25    159701.25    1068.8155    1068.8155 
Loop time of 51.7732 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.381 hours/ns, 19.315 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    | 51.097     | 51.097     | 51.097     |   0.0 | 98.69
Neigh   | 0.037555   | 0.037555   | 0.037555   |   0.0 |  0.07
Comm    | 0.045881   | 0.045881   | 0.045881   |   0.0 |  0.09
Output  | 0.00011037 | 0.00011037 | 0.00011037 |   0.0 |  0.00
Modify  | 0.53543    | 0.53543    | 0.53543    |   0.0 |  1.03
Other   |            | 0.05698    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227000.0 ave      227000 max      227000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227000
Ave neighs/atom = 28.375000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.205173372488, Press = -0.589534983406524
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -36427.843   -36427.843   -36732.377   -36732.377    294.53368    294.53368    159701.25    159701.25    1068.8155    1068.8155 
   45000   -36426.028   -36426.028   -36727.927   -36727.927    291.98543    291.98543    159837.24    159837.24    223.64852    223.64852 
Loop time of 51.8742 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.666 ns/day, 14.409 hours/ns, 19.277 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    | 51.086     | 51.086     | 51.086     |   0.0 | 98.48
Neigh   | 0.15043    | 0.15043    | 0.15043    |   0.0 |  0.29
Comm    | 0.047021   | 0.047021   | 0.047021   |   0.0 |  0.09
Output  | 0.00012944 | 0.00012944 | 0.00012944 |   0.0 |  0.00
Modify  | 0.53485    | 0.53485    | 0.53485    |   0.0 |  1.03
Other   |            | 0.05619    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5035.00 ave        5035 max        5035 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226724.0 ave      226724 max      226724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226724
Ave neighs/atom = 28.340500
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.211664910514, Press = -0.711314255349995
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -36426.028   -36426.028   -36727.927   -36727.927    291.98543    291.98543    159837.24    159837.24    223.64852    223.64852 
   46000   -36432.713   -36432.713   -36731.412   -36731.412    288.89111    288.89111    159820.59    159820.59    231.47435    231.47435 
Loop time of 51.6805 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.356 hours/ns, 19.350 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    | 51.044     | 51.044     | 51.044     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0443     | 0.0443     | 0.0443     |   0.0 |  0.09
Output  | 0.00011397 | 0.00011397 | 0.00011397 |   0.0 |  0.00
Modify  | 0.5349     | 0.5349     | 0.5349     |   0.0 |  1.04
Other   |            | 0.05718    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5049.00 ave        5049 max        5049 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227090.0 ave      227090 max      227090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227090
Ave neighs/atom = 28.386250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.195852911879, Press = -0.797470242416701
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -36432.713   -36432.713   -36731.412   -36731.412    288.89111    288.89111    159820.59    159820.59    231.47435    231.47435 
   47000   -36427.766   -36427.766   -36725.906   -36725.906    288.35024    288.35024       159923       159923   -412.41463   -412.41463 
Loop time of 51.6546 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.673 ns/day, 14.348 hours/ns, 19.359 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    | 51.019     | 51.019     | 51.019     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044199   | 0.044199   | 0.044199   |   0.0 |  0.09
Output  | 9.3151e-05 | 9.3151e-05 | 9.3151e-05 |   0.0 |  0.00
Modify  | 0.53499    | 0.53499    | 0.53499    |   0.0 |  1.04
Other   |            | 0.05679    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5040.00 ave        5040 max        5040 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226954.0 ave      226954 max      226954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226954
Ave neighs/atom = 28.369250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.178511968913, Press = -1.26550052238492
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -36427.766   -36427.766   -36725.906   -36725.906    288.35024    288.35024       159923       159923   -412.41463   -412.41463 
   48000   -36429.044   -36429.044   -36730.609   -36730.609    291.66228    291.66228    159770.59    159770.59    341.17271    341.17271 
Loop time of 51.8507 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.666 ns/day, 14.403 hours/ns, 19.286 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    | 51.1       | 51.1       | 51.1       |   0.0 | 98.55
Neigh   | 0.11291    | 0.11291    | 0.11291    |   0.0 |  0.22
Comm    | 0.046704   | 0.046704   | 0.046704   |   0.0 |  0.09
Output  | 0.00011382 | 0.00011382 | 0.00011382 |   0.0 |  0.00
Modify  | 0.53497    | 0.53497    | 0.53497    |   0.0 |  1.03
Other   |            | 0.05636    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5062.00 ave        5062 max        5062 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227062.0 ave      227062 max      227062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227062
Ave neighs/atom = 28.382750
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.150084087655, Press = -0.851631582318913
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -36429.044   -36429.044   -36730.609   -36730.609    291.66228    291.66228    159770.59    159770.59    341.17271    341.17271 
   49000   -36429.782   -36429.782   -36729.837   -36729.837     290.2016     290.2016    159843.58    159843.58    92.220945    92.220945 
Loop time of 51.7786 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.383 hours/ns, 19.313 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    | 51.103     | 51.103     | 51.103     |   0.0 | 98.69
Neigh   | 0.037643   | 0.037643   | 0.037643   |   0.0 |  0.07
Comm    | 0.046409   | 0.046409   | 0.046409   |   0.0 |  0.09
Output  | 0.00011421 | 0.00011421 | 0.00011421 |   0.0 |  0.00
Modify  | 0.53492    | 0.53492    | 0.53492    |   0.0 |  1.03
Other   |            | 0.05681    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5035.00 ave        5035 max        5035 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226874.0 ave      226874 max      226874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226874
Ave neighs/atom = 28.359250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.155388098548, Press = -1.38250958664312
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -36429.782   -36429.782   -36729.837   -36729.837     290.2016     290.2016    159843.58    159843.58    92.220945    92.220945 
   50000   -36418.199   -36418.199    -36726.26    -36726.26    297.94468    297.94468    159733.51    159733.51    676.09192    676.09192 
Loop time of 51.6776 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.355 hours/ns, 19.351 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    | 51.041     | 51.041     | 51.041     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0444     | 0.0444     | 0.0444     |   0.0 |  0.09
Output  | 0.00011519 | 0.00011519 | 0.00011519 |   0.0 |  0.00
Modify  | 0.53516    | 0.53516    | 0.53516    |   0.0 |  1.04
Other   |            | 0.05662    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5030.00 ave        5030 max        5030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227096.0 ave      227096 max      227096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227096
Ave neighs/atom = 28.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 = 293.179439187866, Press = -0.592864279100737
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -36418.199   -36418.199    -36726.26    -36726.26    297.94468    297.94468    159733.51    159733.51    676.09192    676.09192 
   51000   -36428.407   -36428.407   -36731.174   -36731.174    292.82515    292.82515    159826.45    159826.45    87.427281    87.427281 
Loop time of 51.6815 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.356 hours/ns, 19.349 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    | 51.045     | 51.045     | 51.045     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043927   | 0.043927   | 0.043927   |   0.0 |  0.08
Output  | 0.00010947 | 0.00010947 | 0.00010947 |   0.0 |  0.00
Modify  | 0.53485    | 0.53485    | 0.53485    |   0.0 |  1.03
Other   |            | 0.05713    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5059.00 ave        5059 max        5059 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227178.0 ave      227178 max      227178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227178
Ave neighs/atom = 28.397250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.197412837662, Press = -0.427060612075356
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -36428.407   -36428.407   -36731.174   -36731.174    292.82515    292.82515    159826.45    159826.45    87.427281    87.427281 
   52000   -36430.672   -36430.672    -36733.42    -36733.42    292.80601    292.80601    160064.52    160064.52   -1149.3988   -1149.3988 
Loop time of 51.7002 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.361 hours/ns, 19.342 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    | 51.064     | 51.064     | 51.064     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044215   | 0.044215   | 0.044215   |   0.0 |  0.09
Output  | 0.00010597 | 0.00010597 | 0.00010597 |   0.0 |  0.00
Modify  | 0.5349     | 0.5349     | 0.5349     |   0.0 |  1.03
Other   |            | 0.05718    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5041.00 ave        5041 max        5041 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227002.0 ave      227002 max      227002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227002
Ave neighs/atom = 28.375250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.190467598575, Press = -1.26500537795706
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -36430.672   -36430.672    -36733.42    -36733.42    292.80601    292.80601    160064.52    160064.52   -1149.3988   -1149.3988 
   53000   -36426.011   -36426.011   -36728.774   -36728.774    292.82085    292.82085    159774.74    159774.74    245.57654    245.57654 
Loop time of 51.6553 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.673 ns/day, 14.349 hours/ns, 19.359 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    | 51.019     | 51.019     | 51.019     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044131   | 0.044131   | 0.044131   |   0.0 |  0.09
Output  | 9.5482e-05 | 9.5482e-05 | 9.5482e-05 |   0.0 |  0.00
Modify  | 0.53463    | 0.53463    | 0.53463    |   0.0 |  1.03
Other   |            | 0.05696    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5049.00 ave        5049 max        5049 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226768.0 ave      226768 max      226768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226768
Ave neighs/atom = 28.346000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.176577892891, Press = -0.818316956595993
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -36426.011   -36426.011   -36728.774   -36728.774    292.82085    292.82085    159774.74    159774.74    245.57654    245.57654 
   54000   -36429.633   -36429.633   -36730.199   -36730.199    290.69653    290.69653    159702.57    159702.57    837.98861    837.98861 
Loop time of 51.7783 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.383 hours/ns, 19.313 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    | 51.102     | 51.102     | 51.102     |   0.0 | 98.69
Neigh   | 0.037764   | 0.037764   | 0.037764   |   0.0 |  0.07
Comm    | 0.046237   | 0.046237   | 0.046237   |   0.0 |  0.09
Output  | 0.00011355 | 0.00011355 | 0.00011355 |   0.0 |  0.00
Modify  | 0.53485    | 0.53485    | 0.53485    |   0.0 |  1.03
Other   |            | 0.05689    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5052.00 ave        5052 max        5052 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226912.0 ave      226912 max      226912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226912
Ave neighs/atom = 28.364000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.178521503092, Press = -1.04689756819306
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -36429.633   -36429.633   -36730.199   -36730.199    290.69653    290.69653    159702.57    159702.57    837.98861    837.98861 
   55000   -36424.822   -36424.822   -36728.354   -36728.354    293.56438    293.56438     159982.3     159982.3   -509.75687   -509.75687 
Loop time of 51.7888 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.386 hours/ns, 19.309 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    | 51.112     | 51.112     | 51.112     |   0.0 | 98.69
Neigh   | 0.037701   | 0.037701   | 0.037701   |   0.0 |  0.07
Comm    | 0.046747   | 0.046747   | 0.046747   |   0.0 |  0.09
Output  | 0.0001185  | 0.0001185  | 0.0001185  |   0.0 |  0.00
Modify  | 0.53499    | 0.53499    | 0.53499    |   0.0 |  1.03
Other   |            | 0.05688    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5033.00 ave        5033 max        5033 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226824.0 ave      226824 max      226824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226824
Ave neighs/atom = 28.353000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.151050270243, Press = -1.05673795189618
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -36424.822   -36424.822   -36728.354   -36728.354    293.56438    293.56438     159982.3     159982.3   -509.75687   -509.75687 
   56000    -36428.32    -36428.32   -36728.814   -36728.814    290.62713    290.62713    159850.86    159850.86   -112.42444   -112.42444 
Loop time of 51.6648 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.351 hours/ns, 19.356 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    | 51.028     | 51.028     | 51.028     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044284   | 0.044284   | 0.044284   |   0.0 |  0.09
Output  | 0.00011672 | 0.00011672 | 0.00011672 |   0.0 |  0.00
Modify  | 0.53543    | 0.53543    | 0.53543    |   0.0 |  1.04
Other   |            | 0.05688    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5052.00 ave        5052 max        5052 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226928.0 ave      226928 max      226928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226928
Ave neighs/atom = 28.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 = 293.16000182361, Press = -0.961879002510902
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000    -36428.32    -36428.32   -36728.814   -36728.814    290.62713    290.62713    159850.86    159850.86   -112.42444   -112.42444 
   57000   -36433.317   -36433.317   -36736.404   -36736.404     293.1346     293.1346    159684.74    159684.74    1176.0704    1176.0704 
Loop time of 51.6574 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.673 ns/day, 14.349 hours/ns, 19.358 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    | 51.022     | 51.022     | 51.022     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044034   | 0.044034   | 0.044034   |   0.0 |  0.09
Output  | 0.00011336 | 0.00011336 | 0.00011336 |   0.0 |  0.00
Modify  | 0.53486    | 0.53486    | 0.53486    |   0.0 |  1.04
Other   |            | 0.0568     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5048.00 ave        5048 max        5048 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226884.0 ave      226884 max      226884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226884
Ave neighs/atom = 28.360500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.174224344948, Press = -1.1019787303532
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -36433.317   -36433.317   -36736.404   -36736.404     293.1346     293.1346    159684.74    159684.74    1176.0704    1176.0704 
   58000   -36423.716   -36423.716   -36725.347   -36725.347    291.72652    291.72652    159841.28    159841.28    100.38305    100.38305 
Loop time of 51.6658 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.352 hours/ns, 19.355 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.03      | 51.03      | 51.03      |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044179   | 0.044179   | 0.044179   |   0.0 |  0.09
Output  | 8.9582e-05 | 8.9582e-05 | 8.9582e-05 |   0.0 |  0.00
Modify  | 0.53484    | 0.53484    | 0.53484    |   0.0 |  1.04
Other   |            | 0.05654    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5034.00 ave        5034 max        5034 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226886.0 ave      226886 max      226886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226886
Ave neighs/atom = 28.360750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.167380663165, Press = -0.578269508470967
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -36423.716   -36423.716   -36725.347   -36725.347    291.72652    291.72652    159841.28    159841.28    100.38305    100.38305 
   59000   -36427.044   -36427.044   -36732.676   -36732.676    295.59602    295.59602       159890       159890   -124.32589   -124.32589 
Loop time of 51.6855 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.357 hours/ns, 19.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.049     | 51.049     | 51.049     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044489   | 0.044489   | 0.044489   |   0.0 |  0.09
Output  | 0.00010754 | 0.00010754 | 0.00010754 |   0.0 |  0.00
Modify  | 0.53494    | 0.53494    | 0.53494    |   0.0 |  1.03
Other   |            | 0.05672    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5050.00 ave        5050 max        5050 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227004.0 ave      227004 max      227004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227004
Ave neighs/atom = 28.375500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.164079809951, Press = -0.800632154446346
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -36427.044   -36427.044   -36732.676   -36732.676    295.59602    295.59602       159890       159890   -124.32589   -124.32589 
   60000   -36420.965   -36420.965   -36728.339   -36728.339    297.28147    297.28147    159871.91    159871.91    137.33605    137.33605 
Loop time of 51.6705 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.353 hours/ns, 19.353 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    | 51.034     | 51.034     | 51.034     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044136   | 0.044136   | 0.044136   |   0.0 |  0.09
Output  | 0.00010583 | 0.00010583 | 0.00010583 |   0.0 |  0.00
Modify  | 0.53493    | 0.53493    | 0.53493    |   0.0 |  1.04
Other   |            | 0.05703    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226772.0 ave      226772 max      226772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226772
Ave neighs/atom = 28.346500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.163117003598, Press = -0.850383065939694
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -36420.965   -36420.965   -36728.339   -36728.339    297.28147    297.28147    159871.91    159871.91    137.33605    137.33605 
   61000   -36424.704   -36424.704   -36726.629   -36726.629    292.01086    292.01086    159728.54    159728.54    722.47014    722.47014 
Loop time of 51.6639 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.351 hours/ns, 19.356 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    | 51.027     | 51.027     | 51.027     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044172   | 0.044172   | 0.044172   |   0.0 |  0.09
Output  | 0.00010523 | 0.00010523 | 0.00010523 |   0.0 |  0.00
Modify  | 0.53528    | 0.53528    | 0.53528    |   0.0 |  1.04
Other   |            | 0.05721    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5056.00 ave        5056 max        5056 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226980.0 ave      226980 max      226980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226980
Ave neighs/atom = 28.372500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165061201222, Press = -0.68433154506686
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -36424.704   -36424.704   -36726.629   -36726.629    292.01086    292.01086    159728.54    159728.54    722.47014    722.47014 
   62000   -36428.954   -36428.954    -36731.55    -36731.55    292.65898    292.65898    159781.84    159781.84     353.6927     353.6927 
Loop time of 51.8468 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.666 ns/day, 14.402 hours/ns, 19.288 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    | 51.17      | 51.17      | 51.17      |   0.0 | 98.69
Neigh   | 0.037791   | 0.037791   | 0.037791   |   0.0 |  0.07
Comm    | 0.046599   | 0.046599   | 0.046599   |   0.0 |  0.09
Output  | 9.2746e-05 | 9.2746e-05 | 9.2746e-05 |   0.0 |  0.00
Modify  | 0.53533    | 0.53533    | 0.53533    |   0.0 |  1.03
Other   |            | 0.0571     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5058.00 ave        5058 max        5058 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227094.0 ave      227094 max      227094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227094
Ave neighs/atom = 28.386750
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154530900778, Press = -0.872961999823295
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -36428.954   -36428.954    -36731.55    -36731.55    292.65898    292.65898    159781.84    159781.84     353.6927     353.6927 
   63000   -36428.782   -36428.782   -36731.752   -36731.752    293.02109    293.02109     159841.1     159841.1    5.6618316    5.6618316 
Loop time of 51.8908 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.665 ns/day, 14.414 hours/ns, 19.271 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    | 51.139     | 51.139     | 51.139     |   0.0 | 98.55
Neigh   | 0.11286    | 0.11286    | 0.11286    |   0.0 |  0.22
Comm    | 0.046947   | 0.046947   | 0.046947   |   0.0 |  0.09
Output  | 0.00042841 | 0.00042841 | 0.00042841 |   0.0 |  0.00
Modify  | 0.53562    | 0.53562    | 0.53562    |   0.0 |  1.03
Other   |            | 0.05639    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226980.0 ave      226980 max      226980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226980
Ave neighs/atom = 28.372500
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.140979151153, Press = -1.04499948274709
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -36428.782   -36428.782   -36731.752   -36731.752    293.02109    293.02109     159841.1     159841.1    5.6618316    5.6618316 
   64000   -36426.537   -36426.537   -36730.446   -36730.446    293.93012    293.93012    159808.99    159808.99    315.88234    315.88234 
Loop time of 51.6768 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.355 hours/ns, 19.351 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    | 51.04      | 51.04      | 51.04      |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044434   | 0.044434   | 0.044434   |   0.0 |  0.09
Output  | 0.0001121  | 0.0001121  | 0.0001121  |   0.0 |  0.00
Modify  | 0.53489    | 0.53489    | 0.53489    |   0.0 |  1.04
Other   |            | 0.057      |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5052.00 ave        5052 max        5052 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226978.0 ave      226978 max      226978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226978
Ave neighs/atom = 28.372250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.144592576074, Press = -0.31984257404958
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -36426.537   -36426.537   -36730.446   -36730.446    293.93012    293.93012    159808.99    159808.99    315.88234    315.88234 
   65000   -36433.956   -36433.956   -36734.049   -36734.049    290.23859    290.23859    159922.51    159922.51   -410.00122   -410.00122 
Loop time of 51.6853 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.357 hours/ns, 19.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.049     | 51.049     | 51.049     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044417   | 0.044417   | 0.044417   |   0.0 |  0.09
Output  | 0.00010669 | 0.00010669 | 0.00010669 |   0.0 |  0.00
Modify  | 0.53503    | 0.53503    | 0.53503    |   0.0 |  1.04
Other   |            | 0.05685    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226912.0 ave      226912 max      226912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226912
Ave neighs/atom = 28.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 = 293.122439633825, Press = -0.882613145841817
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -36433.956   -36433.956   -36734.049   -36734.049    290.23859    290.23859    159922.51    159922.51   -410.00122   -410.00122 
   66000    -36425.31    -36425.31   -36733.311   -36733.311    297.88689    297.88689    159800.52    159800.52    202.54377    202.54377 
Loop time of 51.7649 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.379 hours/ns, 19.318 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    | 51.089     | 51.089     | 51.089     |   0.0 | 98.69
Neigh   | 0.037624   | 0.037624   | 0.037624   |   0.0 |  0.07
Comm    | 0.04643    | 0.04643    | 0.04643    |   0.0 |  0.09
Output  | 9.9328e-05 | 9.9328e-05 | 9.9328e-05 |   0.0 |  0.00
Modify  | 0.53495    | 0.53495    | 0.53495    |   0.0 |  1.03
Other   |            | 0.05654    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5044.00 ave        5044 max        5044 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226906.0 ave      226906 max      226906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226906
Ave neighs/atom = 28.363250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.104067963123, Press = -0.878068182942776
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -36425.31    -36425.31   -36733.311   -36733.311    297.88689    297.88689    159800.52    159800.52    202.54377    202.54377 
   67000   -36433.373   -36433.373   -36733.152   -36733.152    289.93502    289.93502    159844.37    159844.37    99.187036    99.187036 
Loop time of 51.7622 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.378 hours/ns, 19.319 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    | 51.087     | 51.087     | 51.087     |   0.0 | 98.69
Neigh   | 0.037164   | 0.037164   | 0.037164   |   0.0 |  0.07
Comm    | 0.046119   | 0.046119   | 0.046119   |   0.0 |  0.09
Output  | 0.00010637 | 0.00010637 | 0.00010637 |   0.0 |  0.00
Modify  | 0.53515    | 0.53515    | 0.53515    |   0.0 |  1.03
Other   |            | 0.05696    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5037.00 ave        5037 max        5037 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226904.0 ave      226904 max      226904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226904
Ave neighs/atom = 28.363000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.091923598284, Press = -1.07853605664135
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -36433.373   -36433.373   -36733.152   -36733.152    289.93502    289.93502    159844.37    159844.37    99.187036    99.187036 
   68000   -36424.685   -36424.685   -36726.686   -36726.686    292.08444    292.08444    159968.97    159968.97   -562.49679   -562.49679 
Loop time of 51.6755 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.354 hours/ns, 19.352 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    | 51.039     | 51.039     | 51.039     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04486    | 0.04486    | 0.04486    |   0.0 |  0.09
Output  | 0.00010931 | 0.00010931 | 0.00010931 |   0.0 |  0.00
Modify  | 0.53513    | 0.53513    | 0.53513    |   0.0 |  1.04
Other   |            | 0.0569     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5062.00 ave        5062 max        5062 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226968.0 ave      226968 max      226968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226968
Ave neighs/atom = 28.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 = 293.092916440222, Press = -0.565151915420429
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -36424.685   -36424.685   -36726.686   -36726.686    292.08444    292.08444    159968.97    159968.97   -562.49679   -562.49679 
   69000   -36430.774   -36430.774    -36731.39    -36731.39    290.74519    290.74519    159854.21    159854.21   -227.77812   -227.77812 
Loop time of 51.823 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.395 hours/ns, 19.296 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    | 51.11      | 51.11      | 51.11      |   0.0 | 98.62
Neigh   | 0.074576   | 0.074576   | 0.074576   |   0.0 |  0.14
Comm    | 0.046515   | 0.046515   | 0.046515   |   0.0 |  0.09
Output  | 8.7213e-05 | 8.7213e-05 | 8.7213e-05 |   0.0 |  0.00
Modify  | 0.5354     | 0.5354     | 0.5354     |   0.0 |  1.03
Other   |            | 0.05636    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5054.00 ave        5054 max        5054 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226772.0 ave      226772 max      226772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226772
Ave neighs/atom = 28.346500
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.101557303649, Press = -0.590143010688531
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -36430.774   -36430.774    -36731.39    -36731.39    290.74519    290.74519    159854.21    159854.21   -227.77812   -227.77812 
   70000   -36425.925   -36425.925   -36724.556   -36724.556    288.82474    288.82474     159979.6     159979.6   -768.13275   -768.13275 
Loop time of 51.7186 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.366 hours/ns, 19.335 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    | 51.081     | 51.081     | 51.081     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045137   | 0.045137   | 0.045137   |   0.0 |  0.09
Output  | 0.00011386 | 0.00011386 | 0.00011386 |   0.0 |  0.00
Modify  | 0.53547    | 0.53547    | 0.53547    |   0.0 |  1.04
Other   |            | 0.05706    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5058.00 ave        5058 max        5058 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227122.0 ave      227122 max      227122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227122
Ave neighs/atom = 28.390250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.102097724389, Press = -0.616553778239424
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -36425.925   -36425.925   -36724.556   -36724.556    288.82474    288.82474     159979.6     159979.6   -768.13275   -768.13275 
   71000    -36423.54    -36423.54   -36726.945   -36726.945    293.44197    293.44197     159846.5     159846.5    215.28396    215.28396 
Loop time of 51.6878 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.358 hours/ns, 19.347 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    | 51.052     | 51.052     | 51.052     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044196   | 0.044196   | 0.044196   |   0.0 |  0.09
Output  | 0.00011029 | 0.00011029 | 0.00011029 |   0.0 |  0.00
Modify  | 0.53492    | 0.53492    | 0.53492    |   0.0 |  1.03
Other   |            | 0.05699    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5040.00 ave        5040 max        5040 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226962.0 ave      226962 max      226962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226962
Ave neighs/atom = 28.370250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.092470367427, Press = -0.726756608233929
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -36423.54    -36423.54   -36726.945   -36726.945    293.44197    293.44197     159846.5     159846.5    215.28396    215.28396 
   72000   -36430.002   -36430.002   -36727.918   -36727.918    288.13339    288.13339     159718.2     159718.2    804.70666    804.70666 
Loop time of 51.9192 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.664 ns/day, 14.422 hours/ns, 19.261 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.093     | 51.093     | 51.093     |   0.0 | 98.41
Neigh   | 0.18725    | 0.18725    | 0.18725    |   0.0 |  0.36
Comm    | 0.047506   | 0.047506   | 0.047506   |   0.0 |  0.09
Output  | 0.00010581 | 0.00010581 | 0.00010581 |   0.0 |  0.00
Modify  | 0.53505    | 0.53505    | 0.53505    |   0.0 |  1.03
Other   |            | 0.05586    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5043.00 ave        5043 max        5043 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226806.0 ave      226806 max      226806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226806
Ave neighs/atom = 28.350750
Neighbor list builds = 5
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.10661401381, Press = -0.755513804067975
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -36430.002   -36430.002   -36727.918   -36727.918    288.13339    288.13339     159718.2     159718.2    804.70666    804.70666 
   73000   -36424.774   -36424.774   -36727.436   -36727.436    292.72401    292.72401    159886.68    159886.68   -138.66365   -138.66365 
Loop time of 51.7877 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.385 hours/ns, 19.310 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    | 51.112     | 51.112     | 51.112     |   0.0 | 98.70
Neigh   | 0.037368   | 0.037368   | 0.037368   |   0.0 |  0.07
Comm    | 0.046388   | 0.046388   | 0.046388   |   0.0 |  0.09
Output  | 0.00011549 | 0.00011549 | 0.00011549 |   0.0 |  0.00
Modify  | 0.53514    | 0.53514    | 0.53514    |   0.0 |  1.03
Other   |            | 0.0568     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5061.00 ave        5061 max        5061 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226962.0 ave      226962 max      226962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226962
Ave neighs/atom = 28.370250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.111745310786, Press = -0.807179461146096
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -36424.774   -36424.774   -36727.436   -36727.436    292.72401    292.72401    159886.68    159886.68   -138.66365   -138.66365 
   74000   -36429.789   -36429.789   -36731.902   -36731.902    292.19243    292.19243    159834.95    159834.95    51.086791    51.086791 
Loop time of 51.8399 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.400 hours/ns, 19.290 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    | 51.089     | 51.089     | 51.089     |   0.0 | 98.55
Neigh   | 0.11211    | 0.11211    | 0.11211    |   0.0 |  0.22
Comm    | 0.046905   | 0.046905   | 0.046905   |   0.0 |  0.09
Output  | 0.00010756 | 0.00010756 | 0.00010756 |   0.0 |  0.00
Modify  | 0.53519    | 0.53519    | 0.53519    |   0.0 |  1.03
Other   |            | 0.05639    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5051.00 ave        5051 max        5051 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226952.0 ave      226952 max      226952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226952
Ave neighs/atom = 28.369000
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.124884530302, Press = -0.336113463499766
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -36429.789   -36429.789   -36731.902   -36731.902    292.19243    292.19243    159834.95    159834.95    51.086791    51.086791 
   75000   -36421.182   -36421.182   -36726.434   -36726.434    295.22835    295.22835    159917.98    159917.98   -373.59356   -373.59356 
Loop time of 51.6815 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.356 hours/ns, 19.349 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    | 51.044     | 51.044     | 51.044     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044737   | 0.044737   | 0.044737   |   0.0 |  0.09
Output  | 0.00011253 | 0.00011253 | 0.00011253 |   0.0 |  0.00
Modify  | 0.53552    | 0.53552    | 0.53552    |   0.0 |  1.04
Other   |            | 0.05729    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5056.00 ave        5056 max        5056 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226988.0 ave      226988 max      226988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226988
Ave neighs/atom = 28.373500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.134613611907, Press = -0.543391108053875
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -36421.182   -36421.182   -36726.434   -36726.434    295.22835    295.22835    159917.98    159917.98   -373.59356   -373.59356 
   76000   -36429.795   -36429.795   -36735.442   -36735.442    295.61042    295.61042    159843.24    159843.24    344.01496    344.01496 
Loop time of 51.7072 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.363 hours/ns, 19.340 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    | 51.07      | 51.07      | 51.07      |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044516   | 0.044516   | 0.044516   |   0.0 |  0.09
Output  | 9.0185e-05 | 9.0185e-05 | 9.0185e-05 |   0.0 |  0.00
Modify  | 0.53513    | 0.53513    | 0.53513    |   0.0 |  1.03
Other   |            | 0.05709    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227058.0 ave      227058 max      227058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227058
Ave neighs/atom = 28.382250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.141133445068, Press = -0.385655358207902
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -36429.795   -36429.795   -36735.442   -36735.442    295.61042    295.61042    159843.24    159843.24    344.01496    344.01496 
   77000   -36421.715   -36421.715   -36730.372   -36730.372     298.5215     298.5215    159870.03    159870.03   -70.005156   -70.005156 
Loop time of 51.6886 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.672 ns/day, 14.358 hours/ns, 19.347 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    | 51.052     | 51.052     | 51.052     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044723   | 0.044723   | 0.044723   |   0.0 |  0.09
Output  | 0.00011001 | 0.00011001 | 0.00011001 |   0.0 |  0.00
Modify  | 0.53513    | 0.53513    | 0.53513    |   0.0 |  1.04
Other   |            | 0.05714    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5055.00 ave        5055 max        5055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226772.0 ave      226772 max      226772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226772
Ave neighs/atom = 28.346500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.159901572897, Press = -0.634342886966487
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -36421.715   -36421.715   -36730.372   -36730.372     298.5215     298.5215    159870.03    159870.03   -70.005156   -70.005156 
   78000   -36433.479   -36433.479   -36732.607   -36732.607     289.3063     289.3063    159739.11    159739.11    609.65666    609.65666 
Loop time of 51.698 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.361 hours/ns, 19.343 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.062     | 51.062     | 51.062     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044235   | 0.044235   | 0.044235   |   0.0 |  0.09
Output  | 0.00011498 | 0.00011498 | 0.00011498 |   0.0 |  0.00
Modify  | 0.5353     | 0.5353     | 0.5353     |   0.0 |  1.04
Other   |            | 0.05673    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226992.0 ave      226992 max      226992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226992
Ave neighs/atom = 28.374000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154897987303, Press = -0.689745593793373
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -36433.479   -36433.479   -36732.607   -36732.607     289.3063     289.3063    159739.11    159739.11    609.65666    609.65666 
   79000   -36424.613   -36424.613   -36730.958   -36730.958    296.28574    296.28574    159875.84    159875.84    66.049777    66.049777 
Loop time of 51.8203 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.395 hours/ns, 19.297 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    | 51.108     | 51.108     | 51.108     |   0.0 | 98.62
Neigh   | 0.074846   | 0.074846   | 0.074846   |   0.0 |  0.14
Comm    | 0.04589    | 0.04589    | 0.04589    |   0.0 |  0.09
Output  | 0.00010658 | 0.00010658 | 0.00010658 |   0.0 |  0.00
Modify  | 0.5352     | 0.5352     | 0.5352     |   0.0 |  1.03
Other   |            | 0.05661    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226940.0 ave      226940 max      226940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226940
Ave neighs/atom = 28.367500
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.152043255269, Press = -0.67341571181096
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -36424.613   -36424.613   -36730.958   -36730.958    296.28574    296.28574    159875.84    159875.84    66.049777    66.049777 
   80000   -36430.331   -36430.331   -36730.291   -36730.291    290.11047    290.11047    159770.22    159770.22    336.69771    336.69771 
Loop time of 51.8802 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.665 ns/day, 14.411 hours/ns, 19.275 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    | 51.129     | 51.129     | 51.129     |   0.0 | 98.55
Neigh   | 0.11245    | 0.11245    | 0.11245    |   0.0 |  0.22
Comm    | 0.046925   | 0.046925   | 0.046925   |   0.0 |  0.09
Output  | 0.00011092 | 0.00011092 | 0.00011092 |   0.0 |  0.00
Modify  | 0.53534    | 0.53534    | 0.53534    |   0.0 |  1.03
Other   |            | 0.05615    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227048.0 ave      227048 max      227048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227048
Ave neighs/atom = 28.381000
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.15637156572, Press = -0.555366730248832
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -36430.331   -36430.331   -36730.291   -36730.291    290.11047    290.11047    159770.22    159770.22    336.69771    336.69771 
   81000   -36428.653   -36428.653    -36729.13    -36729.13    290.60934    290.60934     159895.9     159895.9   -191.65508   -191.65508 
Loop time of 52.1863 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.656 ns/day, 14.496 hours/ns, 19.162 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    | 51.49      | 51.49      | 51.49      |   0.0 | 98.67
Neigh   | 0.038318   | 0.038318   | 0.038318   |   0.0 |  0.07
Comm    | 0.047497   | 0.047497   | 0.047497   |   0.0 |  0.09
Output  | 0.00011877 | 0.00011877 | 0.00011877 |   0.0 |  0.00
Modify  | 0.54622    | 0.54622    | 0.54622    |   0.0 |  1.05
Other   |            | 0.06366    |            |       |  0.12

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5044.00 ave        5044 max        5044 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226904.0 ave      226904 max      226904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226904
Ave neighs/atom = 28.363000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.166221933873, Press = -0.583498263927915
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -36428.653   -36428.653    -36729.13    -36729.13    290.60934    290.60934     159895.9     159895.9   -191.65508   -191.65508 
   82000   -36425.525   -36425.525   -36727.827   -36727.827    292.37531    292.37531    159913.32    159913.32   -502.12693   -502.12693 
Loop time of 51.803 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.390 hours/ns, 19.304 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    | 51.091     | 51.091     | 51.091     |   0.0 | 98.62
Neigh   | 0.074608   | 0.074608   | 0.074608   |   0.0 |  0.14
Comm    | 0.046343   | 0.046343   | 0.046343   |   0.0 |  0.09
Output  | 0.00010741 | 0.00010741 | 0.00010741 |   0.0 |  0.00
Modify  | 0.53505    | 0.53505    | 0.53505    |   0.0 |  1.03
Other   |            | 0.05631    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226908.0 ave      226908 max      226908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226908
Ave neighs/atom = 28.363500
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.160148449906, Press = -0.701743781297322
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -36425.525   -36425.525   -36727.827   -36727.827    292.37531    292.37531    159913.32    159913.32   -502.12693   -502.12693 
   83000    -36429.12    -36429.12   -36729.877   -36729.877    290.88036    290.88036    159689.81    159689.81    1171.1915    1171.1915 
Loop time of 51.7279 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.369 hours/ns, 19.332 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    | 51.091     | 51.091     | 51.091     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044544   | 0.044544   | 0.044544   |   0.0 |  0.09
Output  | 9.8916e-05 | 9.8916e-05 | 9.8916e-05 |   0.0 |  0.00
Modify  | 0.53529    | 0.53529    | 0.53529    |   0.0 |  1.03
Other   |            | 0.05716    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227060.0 ave      227060 max      227060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227060
Ave neighs/atom = 28.382500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.154578160837, Press = -0.616511550584724
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000    -36429.12    -36429.12   -36729.877   -36729.877    290.88036    290.88036    159689.81    159689.81    1171.1915    1171.1915 
   84000   -36424.136   -36424.136   -36728.729   -36728.729    294.59127    294.59127    159846.43    159846.43   -13.167126   -13.167126 
Loop time of 51.7082 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.363 hours/ns, 19.339 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    | 51.072     | 51.072     | 51.072     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044444   | 0.044444   | 0.044444   |   0.0 |  0.09
Output  | 8.7881e-05 | 8.7881e-05 | 8.7881e-05 |   0.0 |  0.00
Modify  | 0.53523    | 0.53523    | 0.53523    |   0.0 |  1.04
Other   |            | 0.05669    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226936.0 ave      226936 max      226936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226936
Ave neighs/atom = 28.367000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.152445160591, Press = -0.427230576417718
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -36424.136   -36424.136   -36728.729   -36728.729    294.59127    294.59127    159846.43    159846.43   -13.167126   -13.167126 
   85000   -36429.405   -36429.405   -36731.817   -36731.817    292.48207    292.48207    159968.41    159968.41   -693.96141   -693.96141 
Loop time of 51.781 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.669 ns/day, 14.384 hours/ns, 19.312 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    | 51.106     | 51.106     | 51.106     |   0.0 | 98.70
Neigh   | 0.03735    | 0.03735    | 0.03735    |   0.0 |  0.07
Comm    | 0.045615   | 0.045615   | 0.045615   |   0.0 |  0.09
Output  | 0.00011682 | 0.00011682 | 0.00011682 |   0.0 |  0.00
Modify  | 0.53535    | 0.53535    | 0.53535    |   0.0 |  1.03
Other   |            | 0.05696    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5054.00 ave        5054 max        5054 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227048.0 ave      227048 max      227048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227048
Ave neighs/atom = 28.381000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.168842642654, Press = -0.524471191938812
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -36429.405   -36429.405   -36731.817   -36731.817    292.48207    292.48207    159968.41    159968.41   -693.96141   -693.96141 
   86000   -36419.593   -36419.593   -36727.213   -36727.213    297.51943    297.51943    159704.39    159704.39    983.71196    983.71196 
Loop time of 51.7121 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.364 hours/ns, 19.338 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    | 51.076     | 51.076     | 51.076     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044148   | 0.044148   | 0.044148   |   0.0 |  0.09
Output  | 0.00010275 | 0.00010275 | 0.00010275 |   0.0 |  0.00
Modify  | 0.53537    | 0.53537    | 0.53537    |   0.0 |  1.04
Other   |            | 0.05677    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5023.00 ave        5023 max        5023 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226908.0 ave      226908 max      226908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226908
Ave neighs/atom = 28.363500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.177676047768, Press = -0.404005818017911
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -36419.593   -36419.593   -36727.213   -36727.213    297.51943    297.51943    159704.39    159704.39    983.71196    983.71196 
   87000   -36427.854   -36427.854   -36731.156   -36731.156    293.34259    293.34259    159924.31    159924.31   -459.92518   -459.92518 
Loop time of 51.709 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.364 hours/ns, 19.339 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    | 51.072     | 51.072     | 51.072     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044279   | 0.044279   | 0.044279   |   0.0 |  0.09
Output  | 0.00010387 | 0.00010387 | 0.00010387 |   0.0 |  0.00
Modify  | 0.53521    | 0.53521    | 0.53521    |   0.0 |  1.04
Other   |            | 0.05718    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5045.00 ave        5045 max        5045 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227098.0 ave      227098 max      227098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227098
Ave neighs/atom = 28.387250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.192125547967, Press = -0.453015884528172
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -36427.854   -36427.854   -36731.156   -36731.156    293.34259    293.34259    159924.31    159924.31   -459.92518   -459.92518 
   88000   -36424.946   -36424.946   -36726.487   -36726.487    291.63975    291.63975    159880.68    159880.68   -52.395644   -52.395644 
Loop time of 51.7002 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.361 hours/ns, 19.342 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    | 51.063     | 51.063     | 51.063     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044865   | 0.044865   | 0.044865   |   0.0 |  0.09
Output  | 9.9179e-05 | 9.9179e-05 | 9.9179e-05 |   0.0 |  0.00
Modify  | 0.53524    | 0.53524    | 0.53524    |   0.0 |  1.04
Other   |            | 0.05716    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5057.00 ave        5057 max        5057 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226922.0 ave      226922 max      226922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226922
Ave neighs/atom = 28.365250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.189654684313, Press = -0.671527306831364
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -36424.946   -36424.946   -36726.487   -36726.487    291.63975    291.63975    159880.68    159880.68   -52.395644   -52.395644 
   89000    -36432.81    -36432.81   -36732.209   -36732.209    289.56772    289.56772    159774.49    159774.49    137.39619    137.39619 
Loop time of 51.7074 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.363 hours/ns, 19.340 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    | 51.071     | 51.071     | 51.071     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044224   | 0.044224   | 0.044224   |   0.0 |  0.09
Output  | 0.00010438 | 0.00010438 | 0.00010438 |   0.0 |  0.00
Modify  | 0.5355     | 0.5355     | 0.5355     |   0.0 |  1.04
Other   |            | 0.05695    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5036.00 ave        5036 max        5036 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226960.0 ave      226960 max      226960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226960
Ave neighs/atom = 28.370000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.179485616792, Press = -0.358542901427311
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000    -36432.81    -36432.81   -36732.209   -36732.209    289.56772    289.56772    159774.49    159774.49    137.39619    137.39619 
   90000   -36415.931   -36415.931    -36725.74    -36725.74    299.63535    299.63535    159632.08    159632.08    1028.4394    1028.4394 
Loop time of 51.8263 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.396 hours/ns, 19.295 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    | 51.15      | 51.15      | 51.15      |   0.0 | 98.69
Neigh   | 0.037461   | 0.037461   | 0.037461   |   0.0 |  0.07
Comm    | 0.046768   | 0.046768   | 0.046768   |   0.0 |  0.09
Output  | 0.00010364 | 0.00010364 | 0.00010364 |   0.0 |  0.00
Modify  | 0.53552    | 0.53552    | 0.53552    |   0.0 |  1.03
Other   |            | 0.05679    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5055.00 ave        5055 max        5055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227074.0 ave      227074 max      227074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227074
Ave neighs/atom = 28.384250
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.187332433913, Press = -0.375658561249932
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -36415.931   -36415.931    -36725.74    -36725.74    299.63535    299.63535    159632.08    159632.08    1028.4394    1028.4394 
   91000   -36430.177   -36430.177   -36733.489   -36733.489    293.35191    293.35191     159844.4     159844.4   -163.62394   -163.62394 
Loop time of 51.8207 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.395 hours/ns, 19.297 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    | 51.145     | 51.145     | 51.145     |   0.0 | 98.70
Neigh   | 0.037557   | 0.037557   | 0.037557   |   0.0 |  0.07
Comm    | 0.046656   | 0.046656   | 0.046656   |   0.0 |  0.09
Output  | 9.092e-05  | 9.092e-05  | 9.092e-05  |   0.0 |  0.00
Modify  | 0.53512    | 0.53512    | 0.53512    |   0.0 |  1.03
Other   |            | 0.05666    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5061.00 ave        5061 max        5061 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227072.0 ave      227072 max      227072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227072
Ave neighs/atom = 28.384000
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.190420785923, Press = -0.450290695772935
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -36430.177   -36430.177   -36733.489   -36733.489    293.35191    293.35191     159844.4     159844.4   -163.62394   -163.62394 
   92000   -36426.362   -36426.362   -36730.338   -36730.338    293.99466    293.99466    159870.94    159870.94   -70.973587   -70.973587 
Loop time of 51.8264 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.396 hours/ns, 19.295 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    | 51.114     | 51.114     | 51.114     |   0.0 | 98.62
Neigh   | 0.074842   | 0.074842   | 0.074842   |   0.0 |  0.14
Comm    | 0.04602    | 0.04602    | 0.04602    |   0.0 |  0.09
Output  | 0.00010586 | 0.00010586 | 0.00010586 |   0.0 |  0.00
Modify  | 0.53533    | 0.53533    | 0.53533    |   0.0 |  1.03
Other   |            | 0.05653    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5044.00 ave        5044 max        5044 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227102.0 ave      227102 max      227102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227102
Ave neighs/atom = 28.387750
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.202611208385, Press = -0.451748416021569
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -36426.362   -36426.362   -36730.338   -36730.338    293.99466    293.99466    159870.94    159870.94   -70.973587   -70.973587 
   93000   -36425.155   -36425.155   -36730.389   -36730.389    295.21043    295.21043    159852.43    159852.43   -175.94675   -175.94675 
Loop time of 51.8212 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.395 hours/ns, 19.297 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    | 51.108     | 51.108     | 51.108     |   0.0 | 98.62
Neigh   | 0.074885   | 0.074885   | 0.074885   |   0.0 |  0.14
Comm    | 0.046479   | 0.046479   | 0.046479   |   0.0 |  0.09
Output  | 0.00010875 | 0.00010875 | 0.00010875 |   0.0 |  0.00
Modify  | 0.5352     | 0.5352     | 0.5352     |   0.0 |  1.03
Other   |            | 0.0566     |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5046.00 ave        5046 max        5046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226904.0 ave      226904 max      226904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226904
Ave neighs/atom = 28.363000
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.205653909814, Press = -0.734310714367517
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -36425.155   -36425.155   -36730.389   -36730.389    295.21043    295.21043    159852.43    159852.43   -175.94675   -175.94675 
   94000   -36426.618   -36426.618   -36734.007   -36734.007    297.29488    297.29488    159640.61    159640.61    1072.6898    1072.6898 
Loop time of 51.7185 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.671 ns/day, 14.366 hours/ns, 19.335 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    | 51.082     | 51.082     | 51.082     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044288   | 0.044288   | 0.044288   |   0.0 |  0.09
Output  | 0.00010642 | 0.00010642 | 0.00010642 |   0.0 |  0.00
Modify  | 0.53533    | 0.53533    | 0.53533    |   0.0 |  1.04
Other   |            | 0.05684    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5038.00 ave        5038 max        5038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227036.0 ave      227036 max      227036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227036
Ave neighs/atom = 28.379500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.223981450669, Press = -0.415409801516738
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -36426.618   -36426.618   -36734.007   -36734.007    297.29488    297.29488    159640.61    159640.61    1072.6898    1072.6898 
   95000   -36426.244   -36426.244    -36730.89    -36730.89    294.64218    294.64218    159809.83    159809.83    202.37256    202.37256 
Loop time of 51.7309 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.670 ns/day, 14.370 hours/ns, 19.331 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    | 51.094     | 51.094     | 51.094     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044291   | 0.044291   | 0.044291   |   0.0 |  0.09
Output  | 9.708e-05  | 9.708e-05  | 9.708e-05  |   0.0 |  0.00
Modify  | 0.53523    | 0.53523    | 0.53523    |   0.0 |  1.03
Other   |            | 0.05697    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5033.00 ave        5033 max        5033 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227168.0 ave      227168 max      227168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227168
Ave neighs/atom = 28.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 = 293.231869199331, Press = -0.286473724594339
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -36426.244   -36426.244    -36730.89    -36730.89    294.64218    294.64218    159809.83    159809.83    202.37256    202.37256 
   96000   -36421.983   -36421.983   -36729.308   -36729.308    297.23375    297.23375    159872.07    159872.07   -329.70968   -329.70968 
Loop time of 51.809 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.391 hours/ns, 19.302 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    | 51.132     | 51.132     | 51.132     |   0.0 | 98.69
Neigh   | 0.037468   | 0.037468   | 0.037468   |   0.0 |  0.07
Comm    | 0.046526   | 0.046526   | 0.046526   |   0.0 |  0.09
Output  | 0.00011132 | 0.00011132 | 0.00011132 |   0.0 |  0.00
Modify  | 0.53597    | 0.53597    | 0.53597    |   0.0 |  1.03
Other   |            | 0.05675    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5049.00 ave        5049 max        5049 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226982.0 ave      226982 max      226982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226982
Ave neighs/atom = 28.372750
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.249182000958, Press = -0.385204270936657
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -36421.983   -36421.983   -36729.308   -36729.308    297.23375    297.23375    159872.07    159872.07   -329.70968   -329.70968 
   97000   -36430.806   -36430.806   -36731.951   -36731.951    291.25638    291.25638    160016.01    160016.01   -1289.1086   -1289.1086 
Loop time of 51.9079 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.664 ns/day, 14.419 hours/ns, 19.265 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    | 51.082     | 51.082     | 51.082     |   0.0 | 98.41
Neigh   | 0.18715    | 0.18715    | 0.18715    |   0.0 |  0.36
Comm    | 0.047591   | 0.047591   | 0.047591   |   0.0 |  0.09
Output  | 0.00010854 | 0.00010854 | 0.00010854 |   0.0 |  0.00
Modify  | 0.5349     | 0.5349     | 0.5349     |   0.0 |  1.03
Other   |            | 0.05582    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5030.00 ave        5030 max        5030 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226976.0 ave      226976 max      226976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226976
Ave neighs/atom = 28.372000
Neighbor list builds = 5
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.250856657519, Press = -0.373345577083399
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -36430.806   -36430.806   -36731.951   -36731.951    291.25638    291.25638    160016.01    160016.01   -1289.1086   -1289.1086 
   98000   -36423.224   -36423.224   -36727.668   -36727.668    294.44674    294.44674    159745.09    159745.09    460.59576    460.59576 
Loop time of 51.825 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.396 hours/ns, 19.296 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    | 51.075     | 51.075     | 51.075     |   0.0 | 98.55
Neigh   | 0.11179    | 0.11179    | 0.11179    |   0.0 |  0.22
Comm    | 0.046712   | 0.046712   | 0.046712   |   0.0 |  0.09
Output  | 8.5798e-05 | 8.5798e-05 | 8.5798e-05 |   0.0 |  0.00
Modify  | 0.53473    | 0.53473    | 0.53473    |   0.0 |  1.03
Other   |            | 0.05651    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5042.00 ave        5042 max        5042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227032.0 ave      227032 max      227032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227032
Ave neighs/atom = 28.379000
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.260651125969, Press = -0.277600596528202
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -36423.224   -36423.224   -36727.668   -36727.668    294.44674    294.44674    159745.09    159745.09    460.59576    460.59576 
   99000   -36425.116   -36425.116   -36727.561   -36727.561     292.5135     292.5135    159817.98    159817.98    119.97396    119.97396 
Loop time of 51.8026 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.668 ns/day, 14.390 hours/ns, 19.304 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    | 51.089     | 51.089     | 51.089     |   0.0 | 98.62
Neigh   | 0.074966   | 0.074966   | 0.074966   |   0.0 |  0.14
Comm    | 0.046592   | 0.046592   | 0.046592   |   0.0 |  0.09
Output  | 0.00010918 | 0.00010918 | 0.00010918 |   0.0 |  0.00
Modify  | 0.53519    | 0.53519    | 0.53519    |   0.0 |  1.03
Other   |            | 0.05652    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5047.00 ave        5047 max        5047 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227098.0 ave      227098 max      227098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 227098
Ave neighs/atom = 28.387250
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.263475406468, Press = -0.553426693780683
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -36425.116   -36425.116   -36727.561   -36727.561     292.5135     292.5135    159817.98    159817.98    119.97396    119.97396 
  100000   -36422.875   -36422.875   -36725.394   -36725.394    292.58487    292.58487    159911.77    159911.77   -763.58296   -763.58296 
Loop time of 51.8254 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.667 ns/day, 14.396 hours/ns, 19.296 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    | 51.075     | 51.075     | 51.075     |   0.0 | 98.55
Neigh   | 0.1127     | 0.1127     | 0.1127     |   0.0 |  0.22
Comm    | 0.046997   | 0.046997   | 0.046997   |   0.0 |  0.09
Output  | 0.00010599 | 0.00010599 | 0.00010599 |   0.0 |  0.00
Modify  | 0.53481    | 0.53481    | 0.53481    |   0.0 |  1.03
Other   |            | 0.05622    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5051.00 ave        5051 max        5051 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      226932.0 ave      226932 max      226932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 226932
Ave neighs/atom = 28.366500
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.274070546043, Press = -0.437445109031808
next a
jump SELF top
variable a loop 2000
run 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.2
  ghost atom cutoff = 5.2
  binsize = 2.6, bins = 21 21 21
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, ghost, cut 5.2
      pair build: full/bin/ghost
      stencil: full/ghost/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.609 | 4.609 | 4.609 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -36422.875   -36422.875   -36725.394   -36725.394    292.58487    292.58487    159911.77    159911.77   -763.58296   -763.58296 
  101000   -36432.161   -36432.161   -36734.462   -36734.462    292.37398    292.37398    159750.46    159750.46    318.37986    318.37986 
Loop time of 51.6574 on 1 procs for 1000 steps with 8000 atoms

Performance: 1.673 ns/day, 14.349 hours/ns, 19.358 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    | 51.021     | 51.021     | 51.021     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04422    | 0.04422    | 0.04422    |   0.0 |  0.09
Output  | 0.0001011  | 0.0001011  | 0.0001011  |   0.0 |  0.00
Modify  | 0.53468    | 0.53468    | 0.53468    |   0.0 |  1.04
Other   |            | 0.05706    |            |       |  0.11

Nlocal:        8000.00 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5042.00 ave        5042 max        5042 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      227072.0 ave      227072 max      227072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0