# 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.031088903546333*${_u_distance}
variable latticeconst_converted equal 3.031088903546333*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108890354633
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
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 (30.310889 30.310889 30.310889)
  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 (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.004 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_001
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.129123109 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_912978207512_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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -10534.588   -10534.588       -10600       -10600       253.15       253.15    27848.129    27848.129    2508.8826    2508.8826 
    1000    -10464.44    -10464.44   -10534.802   -10534.802    272.30881    272.30881    27998.192    27998.192    656.47035    656.47035 
Loop time of 171.297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.504 ns/day, 47.583 hours/ns, 5.838 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.78     | 170.78     | 170.78     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099855   | 0.099855   | 0.099855   |   0.0 |  0.06
Output  | 0.00022908 | 0.00022908 | 0.00022908 |   0.0 |  0.00
Modify  | 0.35345    | 0.35345    | 0.35345    |   0.0 |  0.21
Other   |            | 0.06105    |            |       |  0.04

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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -10464.44    -10464.44   -10534.802   -10534.802    272.30881    272.30881    27998.192    27998.192    656.47035    656.47035 
    2000    -10466.63    -10466.63   -10535.154   -10535.154    265.19711    265.19711    28035.095    28035.095   -1280.8591   -1280.8591 
Loop time of 178.89 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.37     | 178.37     | 178.37     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10026    | 0.10026    | 0.10026    |   0.0 |  0.06
Output  | 0.00022652 | 0.00022652 | 0.00022652 |   0.0 |  0.00
Modify  | 0.36005    | 0.36005    | 0.36005    |   0.0 |  0.20
Other   |            | 0.06095    |            |       |  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:      133894.0 ave      133894 max      133894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133894
Ave neighs/atom = 66.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -10466.63    -10466.63   -10535.154   -10535.154    265.19711    265.19711    28035.095    28035.095   -1280.8591   -1280.8591 
    3000   -10466.758   -10466.758   -10531.123   -10531.123    249.10012    249.10012    28037.885    28037.885   -1088.5403   -1088.5403 
Loop time of 180.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 50.048 hours/ns, 5.550 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    | 179.64     | 179.64     | 179.64     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.06
Output  | 0.00018669 | 0.00018669 | 0.00018669 |   0.0 |  0.00
Modify  | 0.36594    | 0.36594    | 0.36594    |   0.0 |  0.20
Other   |            | 0.0624     |            |       |  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:      133612.0 ave      133612 max      133612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133612
Ave neighs/atom = 66.806000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -10466.758   -10466.758   -10531.123   -10531.123    249.10012    249.10012    28037.885    28037.885   -1088.5403   -1088.5403 
    4000   -10465.485   -10465.485   -10531.148   -10531.148    254.12404    254.12404    28025.332    28025.332   -650.60163   -650.60163 
Loop time of 180.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.188 hours/ns, 5.535 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    | 180.15     | 180.15     | 180.15     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10182    | 0.10182    | 0.10182    |   0.0 |  0.06
Output  | 0.00023601 | 0.00023601 | 0.00023601 |   0.0 |  0.00
Modify  | 0.3665     | 0.3665     | 0.3665     |   0.0 |  0.20
Other   |            | 0.06201    |            |       |  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:      133784.0 ave      133784 max      133784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133784
Ave neighs/atom = 66.892000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -10465.485   -10465.485   -10531.148   -10531.148    254.12404    254.12404    28025.332    28025.332   -650.60163   -650.60163 
    5000   -10466.717   -10466.717   -10528.967   -10528.967    240.91713    240.91713    27989.646    27989.646    1456.5227    1456.5227 
Loop time of 179.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.997 hours/ns, 5.556 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    | 179.46     | 179.46     | 179.46     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10074    | 0.10074    | 0.10074    |   0.0 |  0.06
Output  | 0.00015458 | 0.00015458 | 0.00015458 |   0.0 |  0.00
Modify  | 0.36522    | 0.36522    | 0.36522    |   0.0 |  0.20
Other   |            | 0.06197    |            |       |  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:      133926.0 ave      133926 max      133926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133926
Ave neighs/atom = 66.963000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.962007485884, Press = 98.2259995636994
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -10466.717   -10466.717   -10528.967   -10528.967    240.91713    240.91713    27989.646    27989.646    1456.5227    1456.5227 
    6000   -10464.945   -10464.945   -10531.174   -10531.174    256.31215    256.31215     27984.67     27984.67    1492.6494    1492.6494 
Loop time of 181.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.439 hours/ns, 5.507 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    | 181.03     | 181.03     | 181.03     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10136    | 0.10136    | 0.10136    |   0.0 |  0.06
Output  | 0.00015351 | 0.00015351 | 0.00015351 |   0.0 |  0.00
Modify  | 0.38602    | 0.38602    | 0.38602    |   0.0 |  0.21
Other   |            | 0.06159    |            |       |  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:      134458.0 ave      134458 max      134458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134458
Ave neighs/atom = 67.229000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.913390453317, Press = -27.2423880686814
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -10464.945   -10464.945   -10531.174   -10531.174    256.31215    256.31215     27984.67     27984.67    1492.6494    1492.6494 
    7000   -10466.922   -10466.922   -10532.012   -10532.012    251.90779    251.90779    28015.579    28015.579   -233.14599   -233.14599 
Loop time of 180.671 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.186 hours/ns, 5.535 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    | 180.13     | 180.13     | 180.13     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.06
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.38199    | 0.38199    | 0.38199    |   0.0 |  0.21
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:      134490.0 ave      134490 max      134490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134490
Ave neighs/atom = 67.245000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.864336419718, Press = -36.6143503512505
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -10466.922   -10466.922   -10532.012   -10532.012    251.90779    251.90779    28015.579    28015.579   -233.14599   -233.14599 
    8000   -10464.972   -10464.972   -10532.807   -10532.807    262.52718    262.52718     28076.32     28076.32   -3411.4113   -3411.4113 
Loop time of 182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.556 hours/ns, 5.494 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    | 181.45     | 181.45     | 181.45     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10111    | 0.10111    | 0.10111    |   0.0 |  0.06
Output  | 0.00015887 | 0.00015887 | 0.00015887 |   0.0 |  0.00
Modify  | 0.38537    | 0.38537    | 0.38537    |   0.0 |  0.21
Other   |            | 0.06185    |            |       |  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:      134112.0 ave      134112 max      134112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134112
Ave neighs/atom = 67.056000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.144015467826, Press = -13.5636073615617
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -10464.972   -10464.972   -10532.807   -10532.807    262.52718    262.52718     28076.32     28076.32   -3411.4113   -3411.4113 
    9000   -10465.883   -10465.883   -10532.364   -10532.364    257.28759    257.28759    28037.022    28037.022   -1259.6825   -1259.6825 
Loop time of 183.072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.472 ns/day, 50.853 hours/ns, 5.462 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    | 182.52     | 182.52     | 182.52     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.06
Output  | 0.00021127 | 0.00021127 | 0.00021127 |   0.0 |  0.00
Modify  | 0.38957    | 0.38957    | 0.38957    |   0.0 |  0.21
Other   |            | 0.06218    |            |       |  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:      133468.0 ave      133468 max      133468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133468
Ave neighs/atom = 66.734000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.38991791769, Press = 1.64018263345315
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -10465.883   -10465.883   -10532.364   -10532.364    257.28759    257.28759    28037.022    28037.022   -1259.6825   -1259.6825 
   10000   -10467.734   -10467.734   -10531.613   -10531.613    247.21543    247.21543    28010.628    28010.628    227.85578    227.85578 
Loop time of 184.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.468 ns/day, 51.242 hours/ns, 5.421 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 183.91     | 183.91     | 183.91     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10223    | 0.10223    | 0.10223    |   0.0 |  0.06
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.39336    | 0.39336    | 0.39336    |   0.0 |  0.21
Other   |            | 0.06254    |            |       |  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:      133820.0 ave      133820 max      133820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133820
Ave neighs/atom = 66.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.160296124604, Press = 3.02941436267624
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -10467.734   -10467.734   -10531.613   -10531.613    247.21543    247.21543    28010.628    28010.628    227.85578    227.85578 
   11000   -10463.273   -10463.273   -10528.943   -10528.943    254.14687    254.14687    28001.621    28001.621    877.53693    877.53693 
Loop time of 182.758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.473 ns/day, 50.766 hours/ns, 5.472 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    | 182.2      | 182.2      | 182.2      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10206    | 0.10206    | 0.10206    |   0.0 |  0.06
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.3903     | 0.3903     | 0.3903     |   0.0 |  0.21
Other   |            | 0.06154    |            |       |  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:      134110.0 ave      134110 max      134110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134110
Ave neighs/atom = 67.055000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.924029188502, Press = 0.344020813245823
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -10463.273   -10463.273   -10528.943   -10528.943    254.14687    254.14687    28001.621    28001.621    877.53693    877.53693 
   12000   -10467.694   -10467.694   -10531.551   -10531.551    247.13397    247.13397    27983.051    27983.051    1489.3918    1489.3918 
Loop time of 182.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.474 ns/day, 50.604 hours/ns, 5.489 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    | 181.62     | 181.62     | 181.62     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.06
Output  | 0.00020037 | 0.00020037 | 0.00020037 |   0.0 |  0.00
Modify  | 0.3862     | 0.3862     | 0.3862     |   0.0 |  0.21
Other   |            | 0.06157    |            |       |  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:      134552.0 ave      134552 max      134552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134552
Ave neighs/atom = 67.276000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.235727406593, Press = -4.1154294661691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -10467.694   -10467.694   -10531.551   -10531.551    247.13397    247.13397    27983.051    27983.051    1489.3918    1489.3918 
   13000    -10463.27    -10463.27   -10532.865   -10532.865    269.33866    269.33866    28020.465    28020.465   -225.03261   -225.03261 
Loop time of 182.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.472 ns/day, 50.806 hours/ns, 5.467 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    | 182.35     | 182.35     | 182.35     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.06
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.39188    | 0.39188    | 0.39188    |   0.0 |  0.21
Other   |            | 0.06254    |            |       |  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:      134310.0 ave      134310 max      134310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134310
Ave neighs/atom = 67.155000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.437409792033, Press = -11.2718585208037
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -10463.27    -10463.27   -10532.865   -10532.865    269.33866    269.33866    28020.465    28020.465   -225.03261   -225.03261 
   14000   -10467.218   -10467.218    -10533.15    -10533.15    255.16444    255.16444    28054.632    28054.632   -2333.3073   -2333.3073 
Loop time of 183.6 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.471 ns/day, 51.000 hours/ns, 5.447 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    | 183.05     | 183.05     | 183.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10157    | 0.10157    | 0.10157    |   0.0 |  0.06
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.38463    | 0.38463    | 0.38463    |   0.0 |  0.21
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:      134064.0 ave      134064 max      134064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134064
Ave neighs/atom = 67.032000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.477303095159, Press = -5.08188939079523
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -10467.218   -10467.218    -10533.15    -10533.15    255.16444    255.16444    28054.632    28054.632   -2333.3073   -2333.3073 
   15000   -10465.683   -10465.683   -10532.365   -10532.365    258.06501    258.06501    28044.137    28044.137    -1699.562    -1699.562 
Loop time of 182.94 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.472 ns/day, 50.817 hours/ns, 5.466 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    | 182.39     | 182.39     | 182.39     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.06
Output  | 0.00052683 | 0.00052683 | 0.00052683 |   0.0 |  0.00
Modify  | 0.38918    | 0.38918    | 0.38918    |   0.0 |  0.21
Other   |            | 0.06187    |            |       |  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:      133518.0 ave      133518 max      133518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133518
Ave neighs/atom = 66.759000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.354137409547, Press = 1.05285087208705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -10465.683   -10465.683   -10532.365   -10532.365    258.06501    258.06501    28044.137    28044.137    -1699.562    -1699.562 
   16000   -10467.079   -10467.079   -10534.136   -10534.136    259.51911    259.51911    28015.728    28015.728    -195.2642    -195.2642 
Loop time of 182.573 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.473 ns/day, 50.715 hours/ns, 5.477 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 182.02     | 182.02     | 182.02     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10165    | 0.10165    | 0.10165    |   0.0 |  0.06
Output  | 0.00015735 | 0.00015735 | 0.00015735 |   0.0 |  0.00
Modify  | 0.38768    | 0.38768    | 0.38768    |   0.0 |  0.21
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:      133778.0 ave      133778 max      133778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133778
Ave neighs/atom = 66.889000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.334059022907, Press = 2.37967000870817
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -10467.079   -10467.079   -10534.136   -10534.136    259.51911    259.51911    28015.728    28015.728    -195.2642    -195.2642 
   17000   -10463.138   -10463.138   -10530.263   -10530.263     259.7839     259.7839    28009.287    28009.287    252.59325    252.59325 
Loop time of 181.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.548 hours/ns, 5.495 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    | 181.42     | 181.42     | 181.42     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10131    | 0.10131    | 0.10131    |   0.0 |  0.06
Output  | 0.00019107 | 0.00019107 | 0.00019107 |   0.0 |  0.00
Modify  | 0.38976    | 0.38976    | 0.38976    |   0.0 |  0.21
Other   |            | 0.06202    |            |       |  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:      133968.0 ave      133968 max      133968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133968
Ave neighs/atom = 66.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.376386597426, Press = 0.180743353252567
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -10463.138   -10463.138   -10530.263   -10530.263     259.7839     259.7839    28009.287    28009.287    252.59325    252.59325 
   18000   -10467.429   -10467.429    -10535.07    -10535.07      261.781      261.781    28003.602    28003.602    310.53226    310.53226 
Loop time of 183.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.471 ns/day, 51.000 hours/ns, 5.447 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    | 183.05     | 183.05     | 183.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10201    | 0.10201    | 0.10201    |   0.0 |  0.06
Output  | 0.00015308 | 0.00015308 | 0.00015308 |   0.0 |  0.00
Modify  | 0.38853    | 0.38853    | 0.38853    |   0.0 |  0.21
Other   |            | 0.0619     |            |       |  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:      134200.0 ave      134200 max      134200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134200
Ave neighs/atom = 67.100000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.501640990423, Press = -0.98014424686845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -10467.429   -10467.429    -10535.07    -10535.07      261.781      261.781    28003.602    28003.602    310.53226    310.53226 
   19000    -10464.66    -10464.66   -10529.418   -10529.418    250.61944    250.61944    28009.788    28009.788    392.87062    392.87062 
Loop time of 182.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.474 ns/day, 50.667 hours/ns, 5.482 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    | 181.85     | 181.85     | 181.85     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10198    | 0.10198    | 0.10198    |   0.0 |  0.06
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.38814    | 0.38814    | 0.38814    |   0.0 |  0.21
Other   |            | 0.06189    |            |       |  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:      133816.0 ave      133816 max      133816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133816
Ave neighs/atom = 66.908000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.529554443509, Press = -1.22335691538899
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -10464.66    -10464.66   -10529.418   -10529.418    250.61944    250.61944    28009.788    28009.788    392.87062    392.87062 
   20000   -10467.139   -10467.139   -10531.372   -10531.372    248.58761    248.58761    28014.947    28014.947   -64.245533   -64.245533 
Loop time of 181.636 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.476 ns/day, 50.455 hours/ns, 5.506 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 181.09     | 181.09     | 181.09     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10132    | 0.10132    | 0.10132    |   0.0 |  0.06
Output  | 0.00015351 | 0.00015351 | 0.00015351 |   0.0 |  0.00
Modify  | 0.38453    | 0.38453    | 0.38453    |   0.0 |  0.21
Other   |            | 0.0614     |            |       |  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:      134476.0 ave      134476 max      134476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134476
Ave neighs/atom = 67.238000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.647481644856, Press = -1.35275176284143
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -10467.139   -10467.139   -10531.372   -10531.372    248.58761    248.58761    28014.947    28014.947   -64.245533   -64.245533 
   21000   -10465.941   -10465.941   -10532.688   -10532.688    258.31893    258.31893    28035.626    28035.626   -1202.3885   -1202.3885 
Loop time of 179.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.482 ns/day, 49.816 hours/ns, 5.576 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.8      | 178.8      | 178.8      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10023    | 0.10023    | 0.10023    |   0.0 |  0.06
Output  | 0.00015718 | 0.00015718 | 0.00015718 |   0.0 |  0.00
Modify  | 0.3783     | 0.3783     | 0.3783     |   0.0 |  0.21
Other   |            | 0.06121    |            |       |  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:      134190.0 ave      134190 max      134190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134190
Ave neighs/atom = 67.095000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.659427717087, Press = 0.406699425556539
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -10465.941   -10465.941   -10532.688   -10532.688    258.31893    258.31893    28035.626    28035.626   -1202.3885   -1202.3885 
   22000   -10466.567   -10466.567    -10532.21    -10532.21    254.04631    254.04631    28001.472    28001.472    745.16003    745.16003 
Loop time of 182.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.473 ns/day, 50.698 hours/ns, 5.479 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    | 181.95     | 181.95     | 181.95     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10397    | 0.10397    | 0.10397    |   0.0 |  0.06
Output  | 0.00017953 | 0.00017953 | 0.00017953 |   0.0 |  0.00
Modify  | 0.40053    | 0.40053    | 0.40053    |   0.0 |  0.22
Other   |            | 0.06269    |            |       |  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:      133786.0 ave      133786 max      133786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133786
Ave neighs/atom = 66.893000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.487273173077, Press = 2.35457255682873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -10466.567   -10466.567    -10532.21    -10532.21    254.04631    254.04631    28001.472    28001.472    745.16003    745.16003 
   23000   -10467.664   -10467.664   -10532.579   -10532.579    251.22784    251.22784    27964.929    27964.929    2567.1496    2567.1496 
Loop time of 182.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.473 ns/day, 50.756 hours/ns, 5.473 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    | 182.17     | 182.17     | 182.17     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10198    | 0.10198    | 0.10198    |   0.0 |  0.06
Output  | 0.00019881 | 0.00019881 | 0.00019881 |   0.0 |  0.00
Modify  | 0.39135    | 0.39135    | 0.39135    |   0.0 |  0.21
Other   |            | 0.06175    |            |       |  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:      134254.0 ave      134254 max      134254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134254
Ave neighs/atom = 67.127000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.413305808437, Press = 0.174857882971837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -10467.664   -10467.664   -10532.579   -10532.579    251.22784    251.22784    27964.929    27964.929    2567.1496    2567.1496 
   24000   -10464.052   -10464.052   -10530.493   -10530.493    257.13194    257.13194    27995.204    27995.204    1090.1728    1090.1728 
Loop time of 184.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.469 ns/day, 51.120 hours/ns, 5.434 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    | 183.47     | 183.47     | 183.47     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10252    | 0.10252    | 0.10252    |   0.0 |  0.06
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.3933     | 0.3933     | 0.3933     |   0.0 |  0.21
Other   |            | 0.06271    |            |       |  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:      134402.0 ave      134402 max      134402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134402
Ave neighs/atom = 67.201000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.383461675286, Press = -2.30935891182867
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -10464.052   -10464.052   -10530.493   -10530.493    257.13194    257.13194    27995.204    27995.204    1090.1728    1090.1728 
   25000   -10465.225   -10465.225   -10531.152   -10531.152    255.14414    255.14414    28021.133    28021.133   -314.34389   -314.34389 
Loop time of 180.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.202 hours/ns, 5.533 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    | 180.18     | 180.18     | 180.18     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1002     | 0.1002     | 0.1002     |   0.0 |  0.06
Output  | 0.00015819 | 0.00015819 | 0.00015819 |   0.0 |  0.00
Modify  | 0.38161    | 0.38161    | 0.38161    |   0.0 |  0.21
Other   |            | 0.06144    |            |       |  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:      134354.0 ave      134354 max      134354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134354
Ave neighs/atom = 67.177000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.521272765859, Press = -1.9881761974565
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -10465.225   -10465.225   -10531.152   -10531.152    255.14414    255.14414    28021.133    28021.133   -314.34389   -314.34389 
   26000   -10469.173   -10469.173   -10532.171   -10532.171    243.80819    243.80819    28025.543    28025.543   -825.11955   -825.11955 
Loop time of 183.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.472 ns/day, 50.875 hours/ns, 5.460 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    | 182.6      | 182.6      | 182.6      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10212    | 0.10212    | 0.10212    |   0.0 |  0.06
Output  | 0.00020027 | 0.00020027 | 0.00020027 |   0.0 |  0.00
Modify  | 0.39003    | 0.39003    | 0.39003    |   0.0 |  0.21
Other   |            | 0.06196    |            |       |  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:      134158.0 ave      134158 max      134158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134158
Ave neighs/atom = 67.079000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.436319214786, Press = -1.18096165339886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -10469.173   -10469.173   -10532.171   -10532.171    243.80819    243.80819    28025.543    28025.543   -825.11955   -825.11955 
   27000   -10466.315   -10466.315   -10532.149   -10532.149    254.78652    254.78652    28021.236    28021.236   -522.56817   -522.56817 
Loop time of 181.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.311 hours/ns, 5.521 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    | 180.58     | 180.58     | 180.58     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10038    | 0.10038    | 0.10038    |   0.0 |  0.06
Output  | 0.00015335 | 0.00015335 | 0.00015335 |   0.0 |  0.00
Modify  | 0.38013    | 0.38013    | 0.38013    |   0.0 |  0.21
Other   |            | 0.06112    |            |       |  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:      134090.0 ave      134090 max      134090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134090
Ave neighs/atom = 67.045000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.314616865279, Press = -0.370161543139365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -10466.315   -10466.315   -10532.149   -10532.149    254.78652    254.78652    28021.236    28021.236   -522.56817   -522.56817 
   28000   -10467.387   -10467.387   -10529.892   -10529.892     241.8978     241.8978    28007.167    28007.167    418.36736    418.36736 
Loop time of 178.969 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 178.43     | 178.43     | 178.43     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10086    | 0.10086    | 0.10086    |   0.0 |  0.06
Output  | 0.00018791 | 0.00018791 | 0.00018791 |   0.0 |  0.00
Modify  | 0.38128    | 0.38128    | 0.38128    |   0.0 |  0.21
Other   |            | 0.0614     |            |       |  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:      133938.0 ave      133938 max      133938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133938
Ave neighs/atom = 66.969000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.319729060395, Press = -0.506600384881026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -10467.387   -10467.387   -10529.892   -10529.892     241.8978     241.8978    28007.167    28007.167    418.36736    418.36736 
   29000   -10466.709   -10466.709   -10531.906   -10531.906    252.31908    252.31908    28010.718    28010.718   -36.478778   -36.478778 
Loop time of 183.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.470 ns/day, 51.017 hours/ns, 5.445 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    | 183.1      | 183.1      | 183.1      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10317    | 0.10317    | 0.10317    |   0.0 |  0.06
Output  | 0.00015732 | 0.00015732 | 0.00015732 |   0.0 |  0.00
Modify  | 0.39477    | 0.39477    | 0.39477    |   0.0 |  0.21
Other   |            | 0.06321    |            |       |  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:      134358.0 ave      134358 max      134358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134358
Ave neighs/atom = 67.179000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.364681864885, Press = -0.639919242723181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -10466.709   -10466.709   -10531.906   -10531.906    252.31908    252.31908    28010.718    28010.718   -36.478778   -36.478778 
   30000   -10468.662   -10468.662   -10532.325   -10532.325    246.38252    246.38252    28005.885    28005.885    151.51167    151.51167 
Loop time of 184.059 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.469 ns/day, 51.128 hours/ns, 5.433 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    | 183.5      | 183.5      | 183.5      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10295    | 0.10295    | 0.10295    |   0.0 |  0.06
Output  | 0.00015132 | 0.00015132 | 0.00015132 |   0.0 |  0.00
Modify  | 0.39687    | 0.39687    | 0.39687    |   0.0 |  0.22
Other   |            | 0.06243    |            |       |  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:      134126.0 ave      134126 max      134126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134126
Ave neighs/atom = 67.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.380039233196, Press = -0.462997971059775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -10468.662   -10468.662   -10532.325   -10532.325    246.38252    246.38252    28005.885    28005.885    151.51167    151.51167 
   31000   -10465.794   -10465.794   -10530.744   -10530.744    251.36007    251.36007    27986.063    27986.063    1490.4801    1490.4801 
Loop time of 180.823 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.229 hours/ns, 5.530 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    | 180.28     | 180.28     | 180.28     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10021    | 0.10021    | 0.10021    |   0.0 |  0.06
Output  | 0.00019968 | 0.00019968 | 0.00019968 |   0.0 |  0.00
Modify  | 0.37998    | 0.37998    | 0.37998    |   0.0 |  0.21
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:      134078.0 ave      134078 max      134078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134078
Ave neighs/atom = 67.039000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.330797157155, Press = -1.06117792882737
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -10465.794   -10465.794   -10530.744   -10530.744    251.36007    251.36007    27986.063    27986.063    1490.4801    1490.4801 
   32000   -10467.837   -10467.837   -10533.658   -10533.658    254.73497    254.73497    28006.118    28006.118    139.37094    139.37094 
Loop time of 180.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.191 hours/ns, 5.534 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    | 180.14     | 180.14     | 180.14     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10128    | 0.10128    | 0.10128    |   0.0 |  0.06
Output  | 0.00015739 | 0.00015739 | 0.00015739 |   0.0 |  0.00
Modify  | 0.38406    | 0.38406    | 0.38406    |   0.0 |  0.21
Other   |            | 0.06119    |            |       |  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:      134432.0 ave      134432 max      134432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134432
Ave neighs/atom = 67.216000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.239229628148, Press = -2.43784213413471
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -10467.837   -10467.837   -10533.658   -10533.658    254.73497    254.73497    28006.118    28006.118    139.37094    139.37094 
   33000   -10465.965   -10465.965     -10530.2     -10530.2    248.59581    248.59581    28048.582    28048.582    -1925.692    -1925.692 
Loop time of 181.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.533 hours/ns, 5.497 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    | 181.36     | 181.36     | 181.36     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10245    | 0.10245    | 0.10245    |   0.0 |  0.06
Output  | 0.00019811 | 0.00019811 | 0.00019811 |   0.0 |  0.00
Modify  | 0.39373    | 0.39373    | 0.39373    |   0.0 |  0.22
Other   |            | 0.06223    |            |       |  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:      134066.0 ave      134066 max      134066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134066
Ave neighs/atom = 67.033000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.214416545432, Press = -2.10562793945409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -10465.965   -10465.965     -10530.2     -10530.2    248.59581    248.59581    28048.582    28048.582    -1925.692    -1925.692 
   34000   -10464.072   -10464.072   -10529.543   -10529.543    253.37642    253.37642    28060.812    28060.812   -2411.4877   -2411.4877 
Loop time of 181.177 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.327 hours/ns, 5.519 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    | 180.62     | 180.62     | 180.62     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.06
Output  | 0.00020273 | 0.00020273 | 0.00020273 |   0.0 |  0.00
Modify  | 0.39061    | 0.39061    | 0.39061    |   0.0 |  0.22
Other   |            | 0.06193    |            |       |  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:      134076.0 ave      134076 max      134076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134076
Ave neighs/atom = 67.038000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
28013.2324302777

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0