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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.323440745472908*${_u_distance}
variable latticeconst_converted equal 3.323440745472908*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.32344074547291
Lattice spacing in x,y,z = 3.3234407 3.3234407 3.3234407
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 (33.234407 33.234407 33.234407)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (33.234407 33.234407 33.234407)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_ParkFellingerLenosky_2012_Ta__MO_105449194206_001
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -16071.173   -16071.173    -16146.92    -16146.92       293.15       293.15    36708.262    36708.262    2204.0492    2204.0492 
    1000   -15991.983   -15991.983   -16068.301   -16068.301    295.36113    295.36113    36823.212    36823.212    1257.7108    1257.7108 
Loop time of 229.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.817 hours/ns, 4.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    | 229.24     | 229.24     | 229.24     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096526   | 0.096526   | 0.096526   |   0.0 |  0.04
Output  | 0.00023769 | 0.00023769 | 0.00023769 |   0.0 |  0.00
Modify  | 0.34009    | 0.34009    | 0.34009    |   0.0 |  0.15
Other   |            | 0.0605     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      224000.0 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -15991.983   -15991.983   -16068.301   -16068.301    295.36113    295.36113    36823.212    36823.212    1257.7108    1257.7108 
    2000   -15992.867   -15992.867   -16069.462   -16069.462    296.42913    296.42913    36868.189    36868.189   -1312.2406   -1312.2406 
Loop time of 231.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.350 hours/ns, 4.317 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    | 231.16     | 231.16     | 231.16     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096209   | 0.096209   | 0.096209   |   0.0 |  0.04
Output  | 0.00018992 | 0.00018992 | 0.00018992 |   0.0 |  0.00
Modify  | 0.34086    | 0.34086    | 0.34086    |   0.0 |  0.15
Other   |            | 0.06115    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212828.0 ave      212828 max      212828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212828
Ave neighs/atom = 106.41400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -15992.867   -15992.867   -16069.462   -16069.462    296.42913    296.42913    36868.189    36868.189   -1312.2406   -1312.2406 
    3000   -15994.004   -15994.004   -16071.142   -16071.142    298.53082    298.53082    36847.282    36847.282     -467.844     -467.844 
Loop time of 231.373 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.270 hours/ns, 4.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    | 230.88     | 230.88     | 230.88     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095004   | 0.095004   | 0.095004   |   0.0 |  0.04
Output  | 0.00018486 | 0.00018486 | 0.00018486 |   0.0 |  0.00
Modify  | 0.34061    | 0.34061    | 0.34061    |   0.0 |  0.15
Other   |            | 0.06123    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212310.0 ave      212310 max      212310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212310
Ave neighs/atom = 106.15500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -15994.004   -15994.004   -16071.142   -16071.142    298.53082    298.53082    36847.282    36847.282     -467.844     -467.844 
    4000   -15996.658   -15996.658   -16073.527   -16073.527    297.49279    297.49279    36796.527    36796.527    1760.5407    1760.5407 
Loop time of 228.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.565 hours/ns, 4.370 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    | 228.34     | 228.34     | 228.34     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094194   | 0.094194   | 0.094194   |   0.0 |  0.04
Output  | 0.00022509 | 0.00022509 | 0.00022509 |   0.0 |  0.00
Modify  | 0.33312    | 0.33312    | 0.33312    |   0.0 |  0.15
Other   |            | 0.06129    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212348.0 ave      212348 max      212348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212348
Ave neighs/atom = 106.17400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -15996.658   -15996.658   -16073.527   -16073.527    297.49279    297.49279    36796.527    36796.527    1760.5407    1760.5407 
    5000   -15992.311   -15992.311   -16074.262   -16074.262    317.15854    317.15854    36790.308    36790.308    2436.5783    2436.5783 
Loop time of 229.071 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.631 hours/ns, 4.365 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    | 228.58     | 228.58     | 228.58     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094051   | 0.094051   | 0.094051   |   0.0 |  0.04
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.33709    | 0.33709    | 0.33709    |   0.0 |  0.15
Other   |            | 0.06155    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212876.0 ave      212876 max      212876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212876
Ave neighs/atom = 106.43800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 289.614803848467, Press = -351.334670077046
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -15992.311   -15992.311   -16074.262   -16074.262    317.15854    317.15854    36790.308    36790.308    2436.5783    2436.5783 
    6000   -15994.331   -15994.331   -16076.208   -16076.208    316.87249    316.87249     36849.53     36849.53   -1030.3934   -1030.3934 
Loop time of 228.745 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.540 hours/ns, 4.372 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    | 228.24     | 228.24     | 228.24     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094639   | 0.094639   | 0.094639   |   0.0 |  0.04
Output  | 0.00015231 | 0.00015231 | 0.00015231 |   0.0 |  0.00
Modify  | 0.35117    | 0.35117    | 0.35117    |   0.0 |  0.15
Other   |            | 0.06081    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213412.0 ave      213412 max      213412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213412
Ave neighs/atom = 106.70600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629629006704, Press = -43.1548406049711
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -15994.331   -15994.331   -16076.208   -16076.208    316.87249    316.87249     36849.53     36849.53   -1030.3934   -1030.3934 
    7000   -15997.484   -15997.484   -16068.035   -16068.035    273.03851    273.03851    36865.585    36865.585   -1206.8065   -1206.8065 
Loop time of 228.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.604 hours/ns, 4.367 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    | 228.47     | 228.47     | 228.47     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094573   | 0.094573   | 0.094573   |   0.0 |  0.04
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.35055    | 0.35055    | 0.35055    |   0.0 |  0.15
Other   |            | 0.06268    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212782.0 ave      212782 max      212782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212782
Ave neighs/atom = 106.39100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.187531887279, Press = -11.0287588307847
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -15997.484   -15997.484   -16068.035   -16068.035    273.03851    273.03851    36865.585    36865.585   -1206.8065   -1206.8065 
    8000   -15993.326   -15993.326   -16073.458   -16073.458    310.12046    310.12046    36868.353    36868.353   -1736.2511   -1736.2511 
Loop time of 228.695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.526 hours/ns, 4.373 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    | 228.19     | 228.19     | 228.19     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094276   | 0.094276   | 0.094276   |   0.0 |  0.04
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.3518     | 0.3518     | 0.3518     |   0.0 |  0.15
Other   |            | 0.06114    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211800.0 ave      211800 max      211800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211800
Ave neighs/atom = 105.90000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.018199896265, Press = -30.6035117907874
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -15993.326   -15993.326   -16073.458   -16073.458    310.12046    310.12046    36868.353    36868.353   -1736.2511   -1736.2511 
    9000   -15994.936   -15994.936   -16070.717   -16070.717    293.28103    293.28103     36811.01     36811.01    1377.8767    1377.8767 
Loop time of 228.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.547 hours/ns, 4.371 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    | 228.26     | 228.26     | 228.26     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09477    | 0.09477    | 0.09477    |   0.0 |  0.04
Output  | 0.00015313 | 0.00015313 | 0.00015313 |   0.0 |  0.00
Modify  | 0.35084    | 0.35084    | 0.35084    |   0.0 |  0.15
Other   |            | 0.06117    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212384.0 ave      212384 max      212384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212384
Ave neighs/atom = 106.19200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.23352810268, Press = -14.7089686023218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -15994.936   -15994.936   -16070.717   -16070.717    293.28103    293.28103     36811.01     36811.01    1377.8767    1377.8767 
   10000   -15992.539   -15992.539    -16072.85    -16072.85    310.81106    310.81106    36869.332    36869.332   -1758.0782   -1758.0782 
Loop time of 228.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.557 hours/ns, 4.371 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    | 228.3      | 228.3      | 228.3      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094468   | 0.094468   | 0.094468   |   0.0 |  0.04
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.35133    | 0.35133    | 0.35133    |   0.0 |  0.15
Other   |            | 0.06116    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212930.0 ave      212930 max      212930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212930
Ave neighs/atom = 106.46500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.614722231007, Press = -12.9572051266843
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -15992.539   -15992.539    -16072.85    -16072.85    310.81106    310.81106    36869.332    36869.332   -1758.0782   -1758.0782 
   11000   -15991.879   -15991.879   -16066.326   -16066.326      288.117      288.117    36863.853    36863.853   -1008.6469   -1008.6469 
Loop time of 228.727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.535 hours/ns, 4.372 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    | 228.22     | 228.22     | 228.22     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094557   | 0.094557   | 0.094557   |   0.0 |  0.04
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.35152    | 0.35152    | 0.35152    |   0.0 |  0.15
Other   |            | 0.06132    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212518.0 ave      212518 max      212518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212518
Ave neighs/atom = 106.25900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.964286951329, Press = -11.2335491985956
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -15991.879   -15991.879   -16066.326   -16066.326      288.117      288.117    36863.853    36863.853   -1008.6469   -1008.6469 
   12000   -15991.952   -15991.952   -16070.219   -16070.219    302.90093    302.90093    36841.986    36841.986    54.096553    54.096553 
Loop time of 228.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.529 hours/ns, 4.372 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    | 228.2      | 228.2      | 228.2      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094484   | 0.094484   | 0.094484   |   0.0 |  0.04
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.35115    | 0.35115    | 0.35115    |   0.0 |  0.15
Other   |            | 0.06136    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212262.0 ave      212262 max      212262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212262
Ave neighs/atom = 106.13100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.720460407151, Press = -10.3609142412634
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -15991.952   -15991.952   -16070.219   -16070.219    302.90093    302.90093    36841.986    36841.986    54.096553    54.096553 
   13000   -15996.363   -15996.363   -16073.257   -16073.257    297.58486    297.58486    36868.356    36868.356   -1837.7011   -1837.7011 
Loop time of 228.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.519 hours/ns, 4.373 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    | 228.16     | 228.16     | 228.16     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094651   | 0.094651   | 0.094651   |   0.0 |  0.04
Output  | 0.00015316 | 0.00015316 | 0.00015316 |   0.0 |  0.00
Modify  | 0.3514     | 0.3514     | 0.3514     |   0.0 |  0.15
Other   |            | 0.06102    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212362.0 ave      212362 max      212362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212362
Ave neighs/atom = 106.18100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.65413443986, Press = -9.86146138860767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -15996.363   -15996.363   -16073.257   -16073.257    297.58486    297.58486    36868.356    36868.356   -1837.7011   -1837.7011 
   14000   -15994.437   -15994.437   -16067.962   -16067.962     284.5478     284.5478    36891.162    36891.162   -2333.8095   -2333.8095 
Loop time of 228.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.578 hours/ns, 4.369 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    | 228.37     | 228.37     | 228.37     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094069   | 0.094069   | 0.094069   |   0.0 |  0.04
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.35083    | 0.35083    | 0.35083    |   0.0 |  0.15
Other   |            | 0.06139    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212368.0 ave      212368 max      212368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212368
Ave neighs/atom = 106.18400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.679613381548, Press = -4.12070225688464
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -15994.437   -15994.437   -16067.962   -16067.962     284.5478     284.5478    36891.162    36891.162   -2333.8095   -2333.8095 
   15000   -15990.503   -15990.503   -16071.597   -16071.597    313.84183    313.84183    36906.676    36906.676   -3421.8384   -3421.8384 
Loop time of 228.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.473 hours/ns, 4.376 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    | 228        | 228        | 228        |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09448    | 0.09448    | 0.09448    |   0.0 |  0.04
Output  | 0.00043049 | 0.00043049 | 0.00043049 |   0.0 |  0.00
Modify  | 0.35054    | 0.35054    | 0.35054    |   0.0 |  0.15
Other   |            | 0.06167    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211840.0 ave      211840 max      211840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211840
Ave neighs/atom = 105.92000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.809762042117, Press = -10.4614758421089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -15990.503   -15990.503   -16071.597   -16071.597    313.84183    313.84183    36906.676    36906.676   -3421.8384   -3421.8384 
   16000   -15994.994   -15994.994   -16071.549   -16071.549    296.27701    296.27701    36860.625    36860.625   -1229.5737   -1229.5737 
Loop time of 228.59 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.497 hours/ns, 4.375 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    | 228.08     | 228.08     | 228.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094896   | 0.094896   | 0.094896   |   0.0 |  0.04
Output  | 0.00015256 | 0.00015256 | 0.00015256 |   0.0 |  0.00
Modify  | 0.34969    | 0.34969    | 0.34969    |   0.0 |  0.15
Other   |            | 0.06107    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211718.0 ave      211718 max      211718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211718
Ave neighs/atom = 105.85900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.114374838321, Press = -7.94385921804575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -15994.994   -15994.994   -16071.549   -16071.549    296.27701    296.27701    36860.625    36860.625   -1229.5737   -1229.5737 
   17000   -15994.768   -15994.768   -16066.977   -16066.977    279.45601    279.45601    36863.255    36863.255   -1038.7502   -1038.7502 
Loop time of 228.592 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.498 hours/ns, 4.375 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    | 228.09     | 228.09     | 228.09     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093587   | 0.093587   | 0.093587   |   0.0 |  0.04
Output  | 0.00015233 | 0.00015233 | 0.00015233 |   0.0 |  0.00
Modify  | 0.34961    | 0.34961    | 0.34961    |   0.0 |  0.15
Other   |            | 0.06082    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212210.0 ave      212210 max      212210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212210
Ave neighs/atom = 106.10500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.069832902939, Press = -6.22982897229392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -15994.768   -15994.768   -16066.977   -16066.977    279.45601    279.45601    36863.255    36863.255   -1038.7502   -1038.7502 
   18000   -15994.189   -15994.189   -16075.077   -16075.077    313.04439    313.04439    36869.058    36869.058   -1901.3928   -1901.3928 
Loop time of 234.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.185 hours/ns, 4.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    | 234.14     | 234.14     | 234.14     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09754    | 0.09754    | 0.09754    |   0.0 |  0.04
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.36651    | 0.36651    | 0.36651    |   0.0 |  0.16
Other   |            | 0.06178    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211986.0 ave      211986 max      211986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211986
Ave neighs/atom = 105.99300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.910483342582, Press = -5.92776356939432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -15994.189   -15994.189   -16075.077   -16075.077    313.04439    313.04439    36869.058    36869.058   -1901.3928   -1901.3928 
   19000   -15995.138   -15995.138   -16073.235   -16073.235    302.24213    302.24213    36825.887    36825.887    416.63745    416.63745 
Loop time of 229.01 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.614 hours/ns, 4.367 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    | 228.5      | 228.5      | 228.5      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094968   | 0.094968   | 0.094968   |   0.0 |  0.04
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.35076    | 0.35076    | 0.35076    |   0.0 |  0.15
Other   |            | 0.0595     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212434.0 ave      212434 max      212434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212434
Ave neighs/atom = 106.21700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.996670642549, Press = -8.1157632463578
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -15995.138   -15995.138   -16073.235   -16073.235    302.24213    302.24213    36825.887    36825.887    416.63745    416.63745 
   20000   -15993.695   -15993.695   -16072.378   -16072.378    304.51076    304.51076    36802.568    36802.568    1921.6019    1921.6019 
Loop time of 229.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.666 hours/ns, 4.363 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    | 228.69     | 228.69     | 228.69     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095426   | 0.095426   | 0.095426   |   0.0 |  0.04
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.35082    | 0.35082    | 0.35082    |   0.0 |  0.15
Other   |            | 0.05979    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212688.0 ave      212688 max      212688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212688
Ave neighs/atom = 106.34400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817938228097, Press = -4.20182939421332
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -15993.695   -15993.695   -16072.378   -16072.378    304.51076    304.51076    36802.568    36802.568    1921.6019    1921.6019 
   21000   -15992.753   -15992.753    -16072.53    -16072.53    308.74379    308.74379    36859.795    36859.795   -1155.7974   -1155.7974 
Loop time of 253.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.341 ns/day, 70.315 hours/ns, 3.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 252.54     | 252.54     | 252.54     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10425    | 0.10425    | 0.10425    |   0.0 |  0.04
Output  | 0.00019064 | 0.00019064 | 0.00019064 |   0.0 |  0.00
Modify  | 0.41807    | 0.41807    | 0.41807    |   0.0 |  0.17
Other   |            | 0.06534    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213296.0 ave      213296 max      213296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213296
Ave neighs/atom = 106.64800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878573836685, Press = -3.58603060182837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -15992.753   -15992.753    -16072.53    -16072.53    308.74379    308.74379    36859.795    36859.795   -1155.7974   -1155.7974 
   22000   -15994.245   -15994.245   -16069.726   -16069.726    292.11951    292.11951    36862.779    36862.779   -1155.9079   -1155.9079 
Loop time of 261.037 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.510 hours/ns, 3.831 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.42     | 260.42     | 260.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10738    | 0.10738    | 0.10738    |   0.0 |  0.04
Output  | 0.00015639 | 0.00015639 | 0.00015639 |   0.0 |  0.00
Modify  | 0.44477    | 0.44477    | 0.44477    |   0.0 |  0.17
Other   |            | 0.06791    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212318.0 ave      212318 max      212318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212318
Ave neighs/atom = 106.15900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.872303818393, Press = -4.33554091022627
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -15994.245   -15994.245   -16069.726   -16069.726    292.11951    292.11951    36862.779    36862.779   -1155.9079   -1155.9079 
   23000   -15994.721   -15994.721   -16069.616   -16069.616    289.85065    289.85065    36812.817    36812.817    1475.1509    1475.1509 
Loop time of 260.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.389 hours/ns, 3.837 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.98     | 259.98     | 259.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10704    | 0.10704    | 0.10704    |   0.0 |  0.04
Output  | 0.00015879 | 0.00015879 | 0.00015879 |   0.0 |  0.00
Modify  | 0.44285    | 0.44285    | 0.44285    |   0.0 |  0.17
Other   |            | 0.06807    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212460.0 ave      212460 max      212460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212460
Ave neighs/atom = 106.23000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.968475526316, Press = -1.18695891585037
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -15994.721   -15994.721   -16069.616   -16069.616    289.85065    289.85065    36812.817    36812.817    1475.1509    1475.1509 
   24000   -15992.153   -15992.153   -16073.449   -16073.449    314.62205    314.62205    36830.588    36830.588    337.52836    337.52836 
Loop time of 229.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.845 hours/ns, 4.351 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.33     | 229.33     | 229.33     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095151   | 0.095151   | 0.095151   |   0.0 |  0.04
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.35765    | 0.35765    | 0.35765    |   0.0 |  0.16
Other   |            | 0.06102    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212838.0 ave      212838 max      212838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212838
Ave neighs/atom = 106.41900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.041364412494, Press = -3.31573664889121
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -15992.153   -15992.153   -16073.449   -16073.449    314.62205    314.62205    36830.588    36830.588    337.52836    337.52836 
   25000   -15993.455   -15993.455   -16071.247   -16071.247      301.062      301.062    36810.274    36810.274    1540.5086    1540.5086 
Loop time of 233.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 64.974 hours/ns, 4.275 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.38     | 233.38     | 233.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096807   | 0.096807   | 0.096807   |   0.0 |  0.04
Output  | 0.00023109 | 0.00023109 | 0.00023109 |   0.0 |  0.00
Modify  | 0.36926    | 0.36926    | 0.36926    |   0.0 |  0.16
Other   |            | 0.06142    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212896.0 ave      212896 max      212896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212896
Ave neighs/atom = 106.44800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.064270867159, Press = -2.14935112541072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -15993.455   -15993.455   -16071.247   -16071.247      301.062      301.062    36810.274    36810.274    1540.5086    1540.5086 
   26000   -15997.493   -15997.493   -16070.054   -16070.054    280.81758    280.81758    36812.991    36812.991    1359.0544    1359.0544 
Loop time of 260.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.372 hours/ns, 3.838 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    | 259.92     | 259.92     | 259.92     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10804    | 0.10804    | 0.10804    |   0.0 |  0.04
Output  | 0.00015698 | 0.00015698 | 0.00015698 |   0.0 |  0.00
Modify  | 0.44246    | 0.44246    | 0.44246    |   0.0 |  0.17
Other   |            | 0.06735    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213090.0 ave      213090 max      213090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213090
Ave neighs/atom = 106.54500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.143855292893, Press = -1.89126573291043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -15997.493   -15997.493   -16070.054   -16070.054    280.81758    280.81758    36812.991    36812.991    1359.0544    1359.0544 
   27000   -15994.158   -15994.158    -16068.38    -16068.38    287.24637    287.24637     36871.72     36871.72   -1327.3547   -1327.3547 
Loop time of 229.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.748 hours/ns, 4.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    | 228.98     | 228.98     | 228.98     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09536    | 0.09536    | 0.09536    |   0.0 |  0.04
Output  | 0.00015847 | 0.00015847 | 0.00015847 |   0.0 |  0.00
Modify  | 0.3551     | 0.3551     | 0.3551     |   0.0 |  0.15
Other   |            | 0.06029    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212528.0 ave      212528 max      212528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212528
Ave neighs/atom = 106.26400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.124461169038, Press = -1.4324442295461
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -15994.158   -15994.158    -16068.38    -16068.38    287.24637    287.24637     36871.72     36871.72   -1327.3547   -1327.3547 
   28000    -15996.52    -15996.52   -16070.722   -16070.722    287.17169    287.17169    36881.314    36881.314   -2296.0468   -2296.0468 
Loop time of 229.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.617 hours/ns, 4.366 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    | 228.51     | 228.51     | 228.51     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095323   | 0.095323   | 0.095323   |   0.0 |  0.04
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.15
Other   |            | 0.06028    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211902.0 ave      211902 max      211902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211902
Ave neighs/atom = 105.95100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.072726113189, Press = -2.55925037617407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -15996.52    -15996.52   -16070.722   -16070.722    287.17169    287.17169    36881.314    36881.314   -2296.0468   -2296.0468 
   29000   -15992.835   -15992.835   -16069.739   -16069.739    297.62739    297.62739    36911.201    36911.201   -3644.8501   -3644.8501 
Loop time of 251.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.343 ns/day, 69.876 hours/ns, 3.975 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    | 250.97     | 250.97     | 250.97     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10273    | 0.10273    | 0.10273    |   0.0 |  0.04
Output  | 0.00018975 | 0.00018975 | 0.00018975 |   0.0 |  0.00
Modify  | 0.41632    | 0.41632    | 0.41632    |   0.0 |  0.17
Other   |            | 0.0648     |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212070.0 ave      212070 max      212070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212070
Ave neighs/atom = 106.03500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.985353643751, Press = -4.41195648133334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -15992.835   -15992.835   -16069.739   -16069.739    297.62739    297.62739    36911.201    36911.201   -3644.8501   -3644.8501 
   30000   -15991.027   -15991.027   -16067.882   -16067.882    297.43719    297.43719    36810.986    36810.986    1750.2013    1750.2013 
Loop time of 260.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.300 hours/ns, 3.842 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    | 259.66     | 259.66     | 259.66     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10653    | 0.10653    | 0.10653    |   0.0 |  0.04
Output  | 0.00015268 | 0.00015268 | 0.00015268 |   0.0 |  0.00
Modify  | 0.44615    | 0.44615    | 0.44615    |   0.0 |  0.17
Other   |            | 0.06761    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      211546.0 ave      211546 max      211546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 211546
Ave neighs/atom = 105.77300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.052342618435, Press = -4.12629560172943
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -15991.027   -15991.027   -16067.882   -16067.882    297.43719    297.43719    36810.986    36810.986    1750.2013    1750.2013 
   31000   -15993.975   -15993.975   -16070.274   -16070.274    295.28649    295.28649    36793.722    36793.722    2520.6763    2520.6763 
Loop time of 260.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.493 hours/ns, 3.832 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.35     | 260.35     | 260.35     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10636    | 0.10636    | 0.10636    |   0.0 |  0.04
Output  | 0.00019001 | 0.00019001 | 0.00019001 |   0.0 |  0.00
Modify  | 0.44474    | 0.44474    | 0.44474    |   0.0 |  0.17
Other   |            | 0.06675    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212600.0 ave      212600 max      212600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212600
Ave neighs/atom = 106.30000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.074632161148, Press = -0.849741006220153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -15993.975   -15993.975   -16070.274   -16070.274    295.28649    295.28649    36793.722    36793.722    2520.6763    2520.6763 
   32000   -15988.542   -15988.542   -16066.948   -16066.948    303.43962    303.43962    36806.732    36806.732    2096.0045    2096.0045 
Loop time of 261.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.615 hours/ns, 3.825 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.8      | 260.8      | 260.8      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10653    | 0.10653    | 0.10653    |   0.0 |  0.04
Output  | 0.00018508 | 0.00018508 | 0.00018508 |   0.0 |  0.00
Modify  | 0.44014    | 0.44014    | 0.44014    |   0.0 |  0.17
Other   |            | 0.06753    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213196.0 ave      213196 max      213196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213196
Ave neighs/atom = 106.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.143398797451, Press = -0.644646064989777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -15988.542   -15988.542   -16066.948   -16066.948    303.43962    303.43962    36806.732    36806.732    2096.0045    2096.0045 
   33000   -15995.294   -15995.294    -16071.52    -16071.52     295.0031     295.0031     36843.95     36843.95    -285.2184    -285.2184 
Loop time of 261.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.331 ns/day, 72.551 hours/ns, 3.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.57     | 260.57     | 260.57     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10586    | 0.10586    | 0.10586    |   0.0 |  0.04
Output  | 0.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.44485    | 0.44485    | 0.44485    |   0.0 |  0.17
Other   |            | 0.06734    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212720.0 ave      212720 max      212720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212720
Ave neighs/atom = 106.36000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.160403216086, Press = 0.216608292054739
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -15995.294   -15995.294    -16071.52    -16071.52     295.0031     295.0031     36843.95     36843.95    -285.2184    -285.2184 
   34000   -15996.231   -15996.231   -16072.184   -16072.184    293.94538    293.94538      36851.3      36851.3    -717.9152    -717.9152 
Loop time of 260.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.332 ns/day, 72.301 hours/ns, 3.842 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    | 259.67     | 259.67     | 259.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10641    | 0.10641    | 0.10641    |   0.0 |  0.04
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.44229    | 0.44229    | 0.44229    |   0.0 |  0.17
Other   |            | 0.06634    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212420.0 ave      212420 max      212420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212420
Ave neighs/atom = 106.21000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.188476442177, Press = -1.69052418771299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -15996.231   -15996.231   -16072.184   -16072.184    293.94538    293.94538      36851.3      36851.3    -717.9152    -717.9152 
   35000   -15992.488   -15992.488   -16068.196   -16068.196      292.995      292.995    36867.704    36867.704   -1237.3958   -1237.3958 
Loop time of 259.69 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 259.08     | 259.08     | 259.08     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10686    | 0.10686    | 0.10686    |   0.0 |  0.04
Output  | 0.00018666 | 0.00018666 | 0.00018666 |   0.0 |  0.00
Modify  | 0.43956    | 0.43956    | 0.43956    |   0.0 |  0.17
Other   |            | 0.06733    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212724.0 ave      212724 max      212724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212724
Ave neighs/atom = 106.36200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.167807099436, Press = -0.966868437182615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -15992.488   -15992.488   -16068.196   -16068.196      292.995      292.995    36867.704    36867.704   -1237.3958   -1237.3958 
   36000   -15996.341   -15996.341   -16070.517   -16070.517    287.06844    287.06844    36853.102    36853.102    -763.1098    -763.1098 
Loop time of 232.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.709 hours/ns, 4.293 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.43     | 232.43     | 232.43     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095279   | 0.095279   | 0.095279   |   0.0 |  0.04
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.36338    | 0.36338    | 0.36338    |   0.0 |  0.16
Other   |            | 0.06207    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212072.0 ave      212072 max      212072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212072
Ave neighs/atom = 106.03600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.15164000154, Press = -2.60261179227345
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -15996.341   -15996.341   -16070.517   -16070.517    287.06844    287.06844    36853.102    36853.102    -763.1098    -763.1098 
   37000   -15993.728   -15993.728   -16069.252   -16069.252    292.28573    292.28573    36855.356    36855.356     -672.952     -672.952 
Loop time of 229.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.855 hours/ns, 4.350 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.37     | 229.37     | 229.37     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093956   | 0.093956   | 0.093956   |   0.0 |  0.04
Output  | 0.0001532  | 0.0001532  | 0.0001532  |   0.0 |  0.00
Modify  | 0.35834    | 0.35834    | 0.35834    |   0.0 |  0.16
Other   |            | 0.06081    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212246.0 ave      212246 max      212246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212246
Ave neighs/atom = 106.12300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.14788271636, Press = -2.49359914184168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -15993.728   -15993.728   -16069.252   -16069.252    292.28573    292.28573    36855.356    36855.356     -672.952     -672.952 
   38000   -15994.231   -15994.231   -16071.864   -16071.864    300.44694    300.44694    36785.447    36785.447    2615.1524    2615.1524 
Loop time of 229.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.802 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.18     | 229.18     | 229.18     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095059   | 0.095059   | 0.095059   |   0.0 |  0.04
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.35445    | 0.35445    | 0.35445    |   0.0 |  0.15
Other   |            | 0.06051    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212034.0 ave      212034 max      212034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212034
Ave neighs/atom = 106.01700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.178006621409, Press = -1.80866042664912
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -15994.231   -15994.231   -16071.864   -16071.864    300.44694    300.44694    36785.447    36785.447    2615.1524    2615.1524 
   39000   -15991.466   -15991.466   -16070.198   -16070.198    304.69886    304.69886    36823.861    36823.861    1057.2745    1057.2745 
Loop time of 232.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.516 hours/ns, 4.306 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    | 231.74     | 231.74     | 231.74     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096234   | 0.096234   | 0.096234   |   0.0 |  0.04
Output  | 0.00015181 | 0.00015181 | 0.00015181 |   0.0 |  0.00
Modify  | 0.36358    | 0.36358    | 0.36358    |   0.0 |  0.16
Other   |            | 0.06256    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213146.0 ave      213146 max      213146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213146
Ave neighs/atom = 106.57300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.205025371775, Press = -0.992698960795266
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -15991.466   -15991.466   -16070.198   -16070.198    304.69886    304.69886    36823.861    36823.861    1057.2745    1057.2745 
   40000   -15996.939   -15996.939   -16070.979   -16070.979    286.54037    286.54037    36836.434    36836.434    -15.94089    -15.94089 
Loop time of 228.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.444 hours/ns, 4.378 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    | 227.89     | 227.89     | 227.89     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094891   | 0.094891   | 0.094891   |   0.0 |  0.04
Output  | 0.00020018 | 0.00020018 | 0.00020018 |   0.0 |  0.00
Modify  | 0.35482    | 0.35482    | 0.35482    |   0.0 |  0.16
Other   |            | 0.06169    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212576.0 ave      212576 max      212576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212576
Ave neighs/atom = 106.28800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.153419027865, Press = -1.33149834493595
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -15996.939   -15996.939   -16070.979   -16070.979    286.54037    286.54037    36836.434    36836.434    -15.94089    -15.94089 
   41000   -15993.724   -15993.724   -16069.854   -16069.854    294.63128    294.63128    36842.798    36842.798    -126.6856    -126.6856 
Loop time of 228.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.455 hours/ns, 4.378 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    | 227.93     | 227.93     | 227.93     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094477   | 0.094477   | 0.094477   |   0.0 |  0.04
Output  | 0.00019604 | 0.00019604 | 0.00019604 |   0.0 |  0.00
Modify  | 0.35269    | 0.35269    | 0.35269    |   0.0 |  0.15
Other   |            | 0.06152    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212636.0 ave      212636 max      212636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212636
Ave neighs/atom = 106.31800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.110906061369, Press = -0.436016273274131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -15993.724   -15993.724   -16069.854   -16069.854    294.63128    294.63128    36842.798    36842.798    -126.6856    -126.6856 
   42000   -15995.736   -15995.736   -16071.569   -16071.569    293.47974    293.47974    36861.661    36861.661   -1251.1582   -1251.1582 
Loop time of 228.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.459 hours/ns, 4.377 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    | 227.95     | 227.95     | 227.95     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094375   | 0.094375   | 0.094375   |   0.0 |  0.04
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.35214    | 0.35214    | 0.35214    |   0.0 |  0.15
Other   |            | 0.06104    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212348.0 ave      212348 max      212348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212348
Ave neighs/atom = 106.17400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.114002020232, Press = -1.36037722515569
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -15995.736   -15995.736   -16071.569   -16071.569    293.47974    293.47974    36861.661    36861.661   -1251.1582   -1251.1582 
   43000   -15992.574   -15992.574   -16072.868   -16072.868    310.74635    310.74635    36865.789    36865.789   -1545.7712   -1545.7712 
Loop time of 228.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.549 hours/ns, 4.371 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    | 228.26     | 228.26     | 228.26     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095023   | 0.095023   | 0.095023   |   0.0 |  0.04
Output  | 0.00015362 | 0.00015362 | 0.00015362 |   0.0 |  0.00
Modify  | 0.35681    | 0.35681    | 0.35681    |   0.0 |  0.16
Other   |            | 0.06247    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212352.0 ave      212352 max      212352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212352
Ave neighs/atom = 106.17600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.145032739776, Press = -1.89392490900485
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -15992.574   -15992.574   -16072.868   -16072.868    310.74635    310.74635    36865.789    36865.789   -1545.7712   -1545.7712 
   44000   -15995.978   -15995.978   -16070.464   -16070.464    288.26906    288.26906    36837.317    36837.317    154.70295    154.70295 
Loop time of 228.587 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.496 hours/ns, 4.375 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    | 228.08     | 228.08     | 228.08     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094558   | 0.094558   | 0.094558   |   0.0 |  0.04
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.3544     | 0.3544     | 0.3544     |   0.0 |  0.16
Other   |            | 0.06165    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212588.0 ave      212588 max      212588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212588
Ave neighs/atom = 106.29400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.193209972134, Press = -2.06276475067476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -15995.978   -15995.978   -16070.464   -16070.464    288.26906    288.26906    36837.317    36837.317    154.70295    154.70295 
   45000   -15993.101   -15993.101   -16068.749   -16068.749    292.76567    292.76567    36836.093    36836.093      264.034      264.034 
Loop time of 228.493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.470 hours/ns, 4.376 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    | 227.98     | 227.98     | 227.98     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095375   | 0.095375   | 0.095375   |   0.0 |  0.04
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.35335    | 0.35335    | 0.35335    |   0.0 |  0.15
Other   |            | 0.06216    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212566.0 ave      212566 max      212566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212566
Ave neighs/atom = 106.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.237674471491, Press = -1.31197315230074
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -15993.101   -15993.101   -16068.749   -16068.749    292.76567    292.76567    36836.093    36836.093      264.034      264.034 
   46000   -15992.743   -15992.743    -16069.92    -16069.92    298.68185    298.68185     36880.92     36880.92   -2059.2284   -2059.2284 
Loop time of 228.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.411 hours/ns, 4.381 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    | 227.77     | 227.77     | 227.77     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094845   | 0.094845   | 0.094845   |   0.0 |  0.04
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.35225    | 0.35225    | 0.35225    |   0.0 |  0.15
Other   |            | 0.06178    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212492.0 ave      212492 max      212492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212492
Ave neighs/atom = 106.24600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.265044457255, Press = -2.46981704828675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -15992.743   -15992.743    -16069.92    -16069.92    298.68185    298.68185     36880.92     36880.92   -2059.2284   -2059.2284 
   47000   -15996.732   -15996.732   -16071.542   -16071.542    289.52264    289.52264    36809.351    36809.351    1522.7669    1522.7669 
Loop time of 228.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.427 hours/ns, 4.379 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    | 227.83     | 227.83     | 227.83     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094686   | 0.094686   | 0.094686   |   0.0 |  0.04
Output  | 0.00015521 | 0.00015521 | 0.00015521 |   0.0 |  0.00
Modify  | 0.3535     | 0.3535     | 0.3535     |   0.0 |  0.15
Other   |            | 0.06213    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212098.0 ave      212098 max      212098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212098
Ave neighs/atom = 106.04900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.282741346594, Press = -2.13445981238255
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -15996.732   -15996.732   -16071.542   -16071.542    289.52264    289.52264    36809.351    36809.351    1522.7669    1522.7669 
   48000   -15993.213   -15993.213   -16071.187   -16071.187    301.76601    301.76601    36808.246    36808.246    1563.6762    1563.6762 
Loop time of 228.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.492 hours/ns, 4.375 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    | 228.06     | 228.06     | 228.06     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094484   | 0.094484   | 0.094484   |   0.0 |  0.04
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.35173    | 0.35173    | 0.35173    |   0.0 |  0.15
Other   |            | 0.06215    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      213042.0 ave      213042 max      213042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 213042
Ave neighs/atom = 106.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.28696378123, Press = -1.34933817873932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -15993.213   -15993.213   -16071.187   -16071.187    301.76601    301.76601    36808.246    36808.246    1563.6762    1563.6762 
   49000   -15994.604   -15994.604   -16070.302   -16070.302    292.96063    292.96063    36827.052    36827.052    559.82199    559.82199 
Loop time of 228.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.577 hours/ns, 4.369 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    | 228.37     | 228.37     | 228.37     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094851   | 0.094851   | 0.094851   |   0.0 |  0.04
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.35391    | 0.35391    | 0.35391    |   0.0 |  0.15
Other   |            | 0.06162    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212936.0 ave      212936 max      212936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212936
Ave neighs/atom = 106.46800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.270174448149, Press = -0.803681665424324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -15994.604   -15994.604   -16070.302   -16070.302    292.96063    292.96063    36827.052    36827.052    559.82199    559.82199 
   50000   -15992.551   -15992.551   -16069.296   -16069.296    297.01237    297.01237    36842.108    36842.108   -29.514311   -29.514311 
Loop time of 228.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.541 hours/ns, 4.372 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    | 228.24     | 228.24     | 228.24     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095451   | 0.095451   | 0.095451   |   0.0 |  0.04
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.3537     | 0.3537     | 0.3537     |   0.0 |  0.15
Other   |            | 0.06236    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212792.0 ave      212792 max      212792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212792
Ave neighs/atom = 106.39600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.250326075422, Press = -1.18678275297787
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -15992.551   -15992.551   -16069.296   -16069.296    297.01237    297.01237    36842.108    36842.108   -29.514311   -29.514311 
   51000   -15992.831   -15992.831   -16068.782   -16068.782    293.93998    293.93998     36830.29     36830.29    525.66295    525.66295 
Loop time of 228.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.521 hours/ns, 4.373 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    | 228.17     | 228.17     | 228.17     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094489   | 0.094489   | 0.094489   |   0.0 |  0.04
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.35454    | 0.35454    | 0.35454    |   0.0 |  0.16
Other   |            | 0.06253    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212404.0 ave      212404 max      212404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212404
Ave neighs/atom = 106.20200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.258350733761, Press = -0.840108110896331
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -15992.831   -15992.831   -16068.782   -16068.782    293.93998    293.93998     36830.29     36830.29    525.66295    525.66295 
   52000   -15995.889   -15995.889   -16070.546   -16070.546    288.92876    288.92876     36853.57     36853.57   -837.40418   -837.40418 
Loop time of 228.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.561 hours/ns, 4.370 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    | 228.31     | 228.31     | 228.31     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09407    | 0.09407    | 0.09407    |   0.0 |  0.04
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.35323    | 0.35323    | 0.35323    |   0.0 |  0.15
Other   |            | 0.06151    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212444.0 ave      212444 max      212444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212444
Ave neighs/atom = 106.22200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.220616804804, Press = -1.60863910395651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -15995.889   -15995.889   -16070.546   -16070.546    288.92876    288.92876     36853.57     36853.57   -837.40418   -837.40418 
   53000   -15993.202   -15993.202   -16072.568   -16072.568     307.1555     307.1555    36824.365    36824.365    703.46317    703.46317 
Loop time of 228.604 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.501 hours/ns, 4.374 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    | 228.09     | 228.09     | 228.09     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094683   | 0.094683   | 0.094683   |   0.0 |  0.04
Output  | 0.00020084 | 0.00020084 | 0.00020084 |   0.0 |  0.00
Modify  | 0.35293    | 0.35293    | 0.35293    |   0.0 |  0.15
Other   |            | 0.06181    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212318.0 ave      212318 max      212318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212318
Ave neighs/atom = 106.15900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.230755138963, Press = -1.94702426267615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -15993.202   -15993.202   -16072.568   -16072.568     307.1555     307.1555    36824.365    36824.365    703.46317    703.46317 
   54000   -15994.678   -15994.678   -16070.495   -16070.495    293.41974    293.41974    36795.818    36795.818     2235.118     2235.118 
Loop time of 228.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.481 hours/ns, 4.376 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    | 228.02     | 228.02     | 228.02     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094828   | 0.094828   | 0.094828   |   0.0 |  0.04
Output  | 0.00015464 | 0.00015464 | 0.00015464 |   0.0 |  0.00
Modify  | 0.35257    | 0.35257    | 0.35257    |   0.0 |  0.15
Other   |            | 0.06219    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212850.0 ave      212850 max      212850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212850
Ave neighs/atom = 106.42500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25905385071, Press = -1.24443474016385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -15994.678   -15994.678   -16070.495   -16070.495    293.41974    293.41974    36795.818    36795.818     2235.118     2235.118 
   55000   -15997.648   -15997.648   -16071.946   -16071.946    287.54123    287.54123    36785.042    36785.042    2731.4669    2731.4669 
Loop time of 228.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.476 hours/ns, 4.376 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    | 228        | 228        | 228        |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09416    | 0.09416    | 0.09416    |   0.0 |  0.04
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.35261    | 0.35261    | 0.35261    |   0.0 |  0.15
Other   |            | 0.06248    |            |       |  0.03

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      212968.0 ave      212968 max      212968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 212968
Ave neighs/atom = 106.48400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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
36840.7575795858

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0