# 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.031088918447495*${_u_distance}
variable latticeconst_converted equal 3.031088918447495*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891844749
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 0 0) 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 0 0) to (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.002 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_LeeBaskesKim_2001_V__MO_868364924829_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.1295338222    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*1*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 27848.1295338222*1000

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10534.588     -10534.588     -10600         -10600          253.15         253.15         27848.13       27848.13       2508.8612      2508.8612    
      1000  -10464.485     -10464.485     -10534.767     -10534.767      271.99847      271.99847      27998.13       27998.13       656.02742      656.02742    
Loop time of 95.7933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.609 hours/ns, 10.439 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    | 95.312     | 95.312     | 95.312     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074915   | 0.074915   | 0.074915   |   0.0 |  0.08
Output  | 0.00025946 | 0.00025946 | 0.00025946 |   0.0 |  0.00
Modify  | 0.34878    | 0.34878    | 0.34878    |   0.0 |  0.36
Other   |            | 0.05692    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10464.485     -10464.485     -10534.767     -10534.767      271.99847      271.99847      27998.13       27998.13       656.02742      656.02742    
      2000  -10466.629     -10466.629     -10535.155     -10535.155      265.20295      265.20295      28035.149      28035.149     -1285.3311     -1285.3311    
Loop time of 108.101 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.028 hours/ns, 9.251 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    | 107.57     | 107.57     | 107.57     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080749   | 0.080749   | 0.080749   |   0.0 |  0.07
Output  | 0.00020934 | 0.00020934 | 0.00020934 |   0.0 |  0.00
Modify  | 0.39489    | 0.39489    | 0.39489    |   0.0 |  0.37
Other   |            | 0.06026    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10466.629     -10466.629     -10535.155     -10535.155      265.20295      265.20295      28035.149      28035.149     -1285.3311     -1285.3311    
      3000  -10466.807     -10466.807     -10531.055     -10531.055      248.64488      248.64488      28037.927      28037.927     -1089.4202     -1089.4202    
Loop time of 96.5569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.821 hours/ns, 10.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    | 96.092     | 96.092     | 96.092     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073581   | 0.073581   | 0.073581   |   0.0 |  0.08
Output  | 0.00020858 | 0.00020858 | 0.00020858 |   0.0 |  0.00
Modify  | 0.33641    | 0.33641    | 0.33641    |   0.0 |  0.35
Other   |            | 0.05503    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10466.807     -10466.807     -10531.055     -10531.055      248.64488      248.64488      28037.927      28037.927     -1089.4202     -1089.4202    
      4000  -10465.486     -10465.486     -10531.365     -10531.365      254.95615      254.95615      28025.196      28025.196     -642.10079     -642.10079    
Loop time of 96.9 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.917 hours/ns, 10.320 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    | 96.434     | 96.434     | 96.434     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073433   | 0.073433   | 0.073433   |   0.0 |  0.08
Output  | 0.00024664 | 0.00024664 | 0.00024664 |   0.0 |  0.00
Modify  | 0.33788    | 0.33788    | 0.33788    |   0.0 |  0.35
Other   |            | 0.05458    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10465.486     -10465.486     -10531.365     -10531.365      254.95615      254.95615      28025.196      28025.196     -642.10079     -642.10079    
      5000  -10466.731     -10466.731     -10529.024     -10529.024      241.07896      241.07896      27990.078      27990.078      1438.661       1438.661     
Loop time of 96.6583 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.850 hours/ns, 10.346 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    | 96.19      | 96.19      | 96.19      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074107   | 0.074107   | 0.074107   |   0.0 |  0.08
Output  | 0.0001703  | 0.0001703  | 0.0001703  |   0.0 |  0.00
Modify  | 0.33908    | 0.33908    | 0.33908    |   0.0 |  0.35
Other   |            | 0.05442    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.767012194668, Press = 91.4497495489971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10466.731     -10466.731     -10529.024     -10529.024      241.07896      241.07896      27990.078      27990.078      1438.661       1438.661     
      6000  -10464.993     -10464.993     -10531.167     -10531.167      256.0992       256.0992       27984.47       27984.47       1514.2188      1514.2188    
Loop time of 96.2917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.748 hours/ns, 10.385 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.806     | 95.806     | 95.806     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074749   | 0.074749   | 0.074749   |   0.0 |  0.08
Output  | 0.00016912 | 0.00016912 | 0.00016912 |   0.0 |  0.00
Modify  | 0.35603    | 0.35603    | 0.35603    |   0.0 |  0.37
Other   |            | 0.05459    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904180048875, Press = -27.4610485808404
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10464.993     -10464.993     -10531.167     -10531.167      256.0992       256.0992       27984.47       27984.47       1514.2188      1514.2188    
      7000  -10466.972     -10466.972     -10531.817     -10531.817      250.9576       250.9576       28015.228      28015.228     -220.47439     -220.47439    
Loop time of 96.7273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.869 hours/ns, 10.338 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.242     | 96.242     | 96.242     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074121   | 0.074121   | 0.074121   |   0.0 |  0.08
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35636    | 0.35636    | 0.35636    |   0.0 |  0.37
Other   |            | 0.05428    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.804377903417, Press = -38.0312452374878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10466.972     -10466.972     -10531.817     -10531.817      250.9576       250.9576       28015.228      28015.228     -220.47439     -220.47439    
      8000  -10464.318     -10464.318     -10532.657     -10532.657      264.48105      264.48105      28074.663      28074.663     -3268.5175     -3268.5175    
Loop time of 96.5801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.828 hours/ns, 10.354 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    | 96.095     | 96.095     | 96.095     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074027   | 0.074027   | 0.074027   |   0.0 |  0.08
Output  | 0.00016897 | 0.00016897 | 0.00016897 |   0.0 |  0.00
Modify  | 0.35588    | 0.35588    | 0.35588    |   0.0 |  0.37
Other   |            | 0.05465    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.127880004343, Press = -14.8757609940298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10464.318     -10464.318     -10532.657     -10532.657      264.48105      264.48105      28074.663      28074.663     -3268.5175     -3268.5175    
      9000  -10470.126     -10470.126     -10534.819     -10534.819      250.3695       250.3695       28031.99       28031.99      -1304.3511     -1304.3511    
Loop time of 96.6931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.859 hours/ns, 10.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.208     | 96.208     | 96.208     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074382   | 0.074382   | 0.074382   |   0.0 |  0.08
Output  | 0.00017232 | 0.00017232 | 0.00017232 |   0.0 |  0.00
Modify  | 0.35656    | 0.35656    | 0.35656    |   0.0 |  0.37
Other   |            | 0.05437    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.381892377308, Press = 1.2136661463235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10470.126     -10470.126     -10534.819     -10534.819      250.3695       250.3695       28031.99       28031.99      -1304.3511     -1304.3511    
     10000  -10465.646     -10465.646     -10530.779     -10530.779      252.07111      252.07111      28014.18       28014.18       146.03448      146.03448    
Loop time of 96.5332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.815 hours/ns, 10.359 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.048     | 96.048     | 96.048     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074841   | 0.074841   | 0.074841   |   0.0 |  0.08
Output  | 0.00017123 | 0.00017123 | 0.00017123 |   0.0 |  0.00
Modify  | 0.35648    | 0.35648    | 0.35648    |   0.0 |  0.37
Other   |            | 0.05411    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.026288495289, Press = 4.06231581433735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10465.646     -10465.646     -10530.779     -10530.779      252.07111      252.07111      28014.18       28014.18       146.03448      146.03448    
     11000  -10468.84      -10468.84      -10532.346     -10532.346      245.77498      245.77498      27990.413      27990.413      1086.2613      1086.2613    
Loop time of 96.6153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.838 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.129     | 96.129     | 96.129     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074794   | 0.074794   | 0.074794   |   0.0 |  0.08
Output  | 0.00020701 | 0.00020701 | 0.00020701 |   0.0 |  0.00
Modify  | 0.35649    | 0.35649    | 0.35649    |   0.0 |  0.37
Other   |            | 0.05462    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.738410272628, Press = 0.771157951037962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10468.84      -10468.84      -10532.346     -10532.346      245.77498      245.77498      27990.413      27990.413      1086.2613      1086.2613    
     12000  -10465.69      -10465.69      -10530.7       -10530.7        251.59599      251.59599      27981.048      27981.048      1749.9321      1749.9321    
Loop time of 96.2825 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.745 hours/ns, 10.386 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    | 95.797     | 95.797     | 95.797     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07427    | 0.07427    | 0.07427    |   0.0 |  0.08
Output  | 0.00017091 | 0.00017091 | 0.00017091 |   0.0 |  0.00
Modify  | 0.35695    | 0.35695    | 0.35695    |   0.0 |  0.37
Other   |            | 0.0542     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.550855051929, Press = -4.81458284484458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10465.69      -10465.69      -10530.7       -10530.7        251.59599      251.59599      27981.048      27981.048      1749.9321      1749.9321    
     13000  -10467.648     -10467.648     -10534.765     -10534.765      259.75042      259.75042      28018.11       28018.11      -323.27026     -323.27026    
Loop time of 96.2444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.735 hours/ns, 10.390 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    | 95.759     | 95.759     | 95.759     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074073   | 0.074073   | 0.074073   |   0.0 |  0.08
Output  | 0.00017202 | 0.00017202 | 0.00017202 |   0.0 |  0.00
Modify  | 0.35639    | 0.35639    | 0.35639    |   0.0 |  0.37
Other   |            | 0.05457    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.526149215214, Press = -12.9346665809801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10467.648     -10467.648     -10534.765     -10534.765      259.75042      259.75042      28018.11       28018.11      -323.27026     -323.27026    
     14000  -10466.033     -10466.033     -10532.617     -10532.617      257.68711      257.68711      28058.735      28058.735     -2487.6081     -2487.6081    
Loop time of 96.6383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.844 hours/ns, 10.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.153     | 96.153     | 96.153     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07407    | 0.07407    | 0.07407    |   0.0 |  0.08
Output  | 0.00016943 | 0.00016943 | 0.00016943 |   0.0 |  0.00
Modify  | 0.3566     | 0.3566     | 0.3566     |   0.0 |  0.37
Other   |            | 0.05444    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.601931619715, Press = -4.22393807608298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10466.033     -10466.033     -10532.617     -10532.617      257.68711      257.68711      28058.735      28058.735     -2487.6081     -2487.6081    
     15000  -10467.807     -10467.807     -10533.52      -10533.52       254.31667      254.31667      28043.013      28043.013     -1807.4001     -1807.4001    
Loop time of 96.6019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.834 hours/ns, 10.352 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.117     | 96.117     | 96.117     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074816   | 0.074816   | 0.074816   |   0.0 |  0.08
Output  | 0.00016887 | 0.00016887 | 0.00016887 |   0.0 |  0.00
Modify  | 0.35634    | 0.35634    | 0.35634    |   0.0 |  0.37
Other   |            | 0.05397    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405187843732, Press = 1.98878314459699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10467.807     -10467.807     -10533.52      -10533.52       254.31667      254.31667      28043.013      28043.013     -1807.4001     -1807.4001    
     16000  -10465.645     -10465.645     -10533.872     -10533.872      264.04299      264.04299      28014.548      28014.548     -54.866533     -54.866533    
Loop time of 96.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.788 hours/ns, 10.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    | 95.951     | 95.951     | 95.951     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074174   | 0.074174   | 0.074174   |   0.0 |  0.08
Output  | 0.00016694 | 0.00016694 | 0.00016694 |   0.0 |  0.00
Modify  | 0.35596    | 0.35596    | 0.35596    |   0.0 |  0.37
Other   |            | 0.05477    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.434455938405, Press = 3.15900526406166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10465.645     -10465.645     -10533.872     -10533.872      264.04299      264.04299      28014.548      28014.548     -54.866533     -54.866533    
     17000  -10466.379     -10466.379     -10532.352     -10532.352      255.32494      255.32494      27996.016      27996.016      748.36993      748.36993    
Loop time of 96.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.764 hours/ns, 10.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    | 95.867     | 95.867     | 95.867     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074376   | 0.074376   | 0.074376   |   0.0 |  0.08
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.35613    | 0.35613    | 0.35613    |   0.0 |  0.37
Other   |            | 0.05437    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.500098595276, Press = 0.506162814681302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10466.379     -10466.379     -10532.352     -10532.352      255.32494      255.32494      27996.016      27996.016      748.36993      748.36993    
     18000  -10467.07      -10467.07      -10534.63      -10534.63       261.4633       261.4633       27997.806      27997.806      619.61633      619.61633    
Loop time of 96.4768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.799 hours/ns, 10.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    | 95.992     | 95.992     | 95.992     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0741     | 0.0741     | 0.0741     |   0.0 |  0.08
Output  | 0.00016915 | 0.00016915 | 0.00016915 |   0.0 |  0.00
Modify  | 0.35598    | 0.35598    | 0.35598    |   0.0 |  0.37
Other   |            | 0.05459    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.678684755915, Press = -1.48495115024296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10467.07      -10467.07      -10534.63      -10534.63       261.4633       261.4633       27997.806      27997.806      619.61633      619.61633    
     19000  -10464.244     -10464.244     -10529.847     -10529.847      253.89052      253.89052      28015.837      28015.837      51.725656      51.725656    
Loop time of 96.3798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.772 hours/ns, 10.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    | 95.894     | 95.894     | 95.894     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074071   | 0.074071   | 0.074071   |   0.0 |  0.08
Output  | 0.00016936 | 0.00016936 | 0.00016936 |   0.0 |  0.00
Modify  | 0.35611    | 0.35611    | 0.35611    |   0.0 |  0.37
Other   |            | 0.05496    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.794060552367, Press = -1.79797966642977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10464.244     -10464.244     -10529.847     -10529.847      253.89052      253.89052      28015.837      28015.837      51.725656      51.725656    
     20000  -10468.188     -10468.188     -10532.208     -10532.208      247.76302      247.76302      28026.095      28026.095     -781.82334     -781.82334    
Loop time of 96.8755 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.910 hours/ns, 10.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.388     | 96.388     | 96.388     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074616   | 0.074616   | 0.074616   |   0.0 |  0.08
Output  | 0.00017041 | 0.00017041 | 0.00017041 |   0.0 |  0.00
Modify  | 0.35839    | 0.35839    | 0.35839    |   0.0 |  0.37
Other   |            | 0.05443    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902274024052, Press = -1.22949256368588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10468.188     -10468.188     -10532.208     -10532.208      247.76302      247.76302      28026.095      28026.095     -781.82334     -781.82334    
     21000  -10466.06      -10466.06      -10532.746     -10532.746      258.08537      258.08537      28040.336      28040.336     -1503.3461     -1503.3461    
Loop time of 96.5237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.812 hours/ns, 10.360 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    | 96.039     | 96.039     | 96.039     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073515   | 0.073515   | 0.073515   |   0.0 |  0.08
Output  | 0.00017113 | 0.00017113 | 0.00017113 |   0.0 |  0.00
Modify  | 0.35672    | 0.35672    | 0.35672    |   0.0 |  0.37
Other   |            | 0.05453    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.898612085977, Press = 1.66281137526547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10466.06      -10466.06      -10532.746     -10532.746      258.08537      258.08537      28040.336      28040.336     -1503.3461     -1503.3461    
     22000  -10467.905     -10467.905     -10532.989     -10532.989      251.88126      251.88126      27982.235      27982.235      1683.0664      1683.0664    
Loop time of 96.2052 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.724 hours/ns, 10.394 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    | 95.719     | 95.719     | 95.719     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07412    | 0.07412    | 0.07412    |   0.0 |  0.08
Output  | 0.00020393 | 0.00020393 | 0.00020393 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.37
Other   |            | 0.05499    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.948743482244, Press = 3.76523311900813
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10467.905     -10467.905     -10532.989     -10532.989      251.88126      251.88126      27982.235      27982.235      1683.0664      1683.0664    
     23000  -10465.763     -10465.763     -10532.517     -10532.517      258.34818      258.34818      27974.134      27974.134      2146.0208      2146.0208    
Loop time of 96.6145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.837 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.128     | 96.128     | 96.128     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074099   | 0.074099   | 0.074099   |   0.0 |  0.08
Output  | 0.00017137 | 0.00017137 | 0.00017137 |   0.0 |  0.00
Modify  | 0.35817    | 0.35817    | 0.35817    |   0.0 |  0.37
Other   |            | 0.05432    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88185577614, Press = 0.0714510383893654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10465.763     -10465.763     -10532.517     -10532.517      258.34818      258.34818      27974.134      27974.134      2146.0208      2146.0208    
     24000  -10468.045     -10468.045     -10532.542     -10532.542      249.60868      249.60868      28000.999      28000.999      544.38656      544.38656    
Loop time of 96.2146 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.726 hours/ns, 10.393 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    | 95.732     | 95.732     | 95.732     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07319    | 0.07319    | 0.07319    |   0.0 |  0.08
Output  | 0.00017061 | 0.00017061 | 0.00017061 |   0.0 |  0.00
Modify  | 0.35474    | 0.35474    | 0.35474    |   0.0 |  0.37
Other   |            | 0.0548     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871539501214, Press = -1.60092983775759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10468.045     -10468.045     -10532.542     -10532.542      249.60868      249.60868      28000.999      28000.999      544.38656      544.38656    
     25000  -10465.742     -10465.742     -10530.154     -10530.154      249.28212      249.28212      28020.64       28020.64      -259.73324     -259.73324    
Loop time of 96.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.812 hours/ns, 10.360 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    | 96.038     | 96.038     | 96.038     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073697   | 0.073697   | 0.073697   |   0.0 |  0.08
Output  | 0.00017203 | 0.00017203 | 0.00017203 |   0.0 |  0.00
Modify  | 0.35644    | 0.35644    | 0.35644    |   0.0 |  0.37
Other   |            | 0.05429    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.796545923883, Press = -1.38752710501286
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10465.742     -10465.742     -10530.154     -10530.154      249.28212      249.28212      28020.64       28020.64      -259.73324     -259.73324    
     26000  -10467.359     -10467.359     -10531.3       -10531.3        247.45779      247.45779      28037.286      28037.286     -1304.6823     -1304.6823    
Loop time of 96.4242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.784 hours/ns, 10.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    | 95.94      | 95.94      | 95.94      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073005   | 0.073005   | 0.073005   |   0.0 |  0.08
Output  | 0.00020162 | 0.00020162 | 0.00020162 |   0.0 |  0.00
Modify  | 0.35675    | 0.35675    | 0.35675    |   0.0 |  0.37
Other   |            | 0.05443    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115998 ave      115998 max      115998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115998
Ave neighs/atom = 57.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.769614519285, Press = -1.1677613713863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10467.359     -10467.359     -10531.3       -10531.3        247.45779      247.45779      28037.286      28037.286     -1304.6823     -1304.6823    
     27000  -10463.99      -10463.99      -10531.811     -10531.811      262.47397      262.47397      28042.476      28042.476     -1565.3628     -1565.3628    
Loop time of 96.5415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.817 hours/ns, 10.358 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.057     | 96.057     | 96.057     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073959   | 0.073959   | 0.073959   |   0.0 |  0.08
Output  | 0.00017431 | 0.00017431 | 0.00017431 |   0.0 |  0.00
Modify  | 0.35637    | 0.35637    | 0.35637    |   0.0 |  0.37
Other   |            | 0.0543     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.780729087514, Press = 0.784264494485453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10463.99      -10463.99      -10531.811     -10531.811      262.47397      262.47397      28042.476      28042.476     -1565.3628     -1565.3628    
     28000  -10467.332     -10467.332     -10530.029     -10530.029      242.64627      242.64627      27987.939      27987.939      1400.8775      1400.8775    
Loop time of 96.6707 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.853 hours/ns, 10.344 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    | 96.186     | 96.186     | 96.186     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073746   | 0.073746   | 0.073746   |   0.0 |  0.08
Output  | 0.00016912 | 0.00016912 | 0.00016912 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.37
Other   |            | 0.0543     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115998 ave      115998 max      115998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115998
Ave neighs/atom = 57.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870655933384, Press = 2.87161476217255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10467.332     -10467.332     -10530.029     -10530.029      242.64627      242.64627      27987.939      27987.939      1400.8775      1400.8775    
     29000  -10463.665     -10463.665     -10530.02      -10530.02       256.80245      256.80245      27975.828      27975.828      2106.6409      2106.6409    
Loop time of 96.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.809 hours/ns, 10.361 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.028     | 96.028     | 96.028     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073973   | 0.073973   | 0.073973   |   0.0 |  0.08
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.35649    | 0.35649    | 0.35649    |   0.0 |  0.37
Other   |            | 0.05426    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.945710976579, Press = -0.00403421418537299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10463.665     -10463.665     -10530.02      -10530.02       256.80245      256.80245      27975.828      27975.828      2106.6409      2106.6409    
     30000  -10465.176     -10465.176     -10530.53      -10530.53       252.92894      252.92894      28008.785      28008.785      289.76042      289.76042    
Loop time of 96.4066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.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    | 95.922     | 95.922     | 95.922     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073797   | 0.073797   | 0.073797   |   0.0 |  0.08
Output  | 0.00016761 | 0.00016761 | 0.00016761 |   0.0 |  0.00
Modify  | 0.3565     | 0.3565     | 0.3565     |   0.0 |  0.37
Other   |            | 0.05454    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115998 ave      115998 max      115998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115998
Ave neighs/atom = 57.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923063904117, Press = -0.917259931044168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10465.176     -10465.176     -10530.53      -10530.53       252.92894      252.92894      28008.785      28008.785      289.76042      289.76042    
     31000  -10465.579     -10465.579     -10530.457     -10530.457      251.08406      251.08406      28015.436      28015.436     -22.545941     -22.545941    
Loop time of 96.3969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.777 hours/ns, 10.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    | 95.912     | 95.912     | 95.912     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073258   | 0.073258   | 0.073258   |   0.0 |  0.08
Output  | 0.00016882 | 0.00016882 | 0.00016882 |   0.0 |  0.00
Modify  | 0.35674    | 0.35674    | 0.35674    |   0.0 |  0.37
Other   |            | 0.05501    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.890606412194, Press = -1.20384896082121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10465.579     -10465.579     -10530.457     -10530.457      251.08406      251.08406      28015.436      28015.436     -22.545941     -22.545941    
     32000  -10469.747     -10469.747     -10533.87      -10533.87       248.16341      248.16341      28031.813      28031.813     -1268.014      -1268.014     
Loop time of 96.4806 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.800 hours/ns, 10.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    | 95.996     | 95.996     | 95.996     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073864   | 0.073864   | 0.073864   |   0.0 |  0.08
Output  | 0.00018995 | 0.00018995 | 0.00018995 |   0.0 |  0.00
Modify  | 0.35605    | 0.35605    | 0.35605    |   0.0 |  0.37
Other   |            | 0.05462    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815818416431, Press = -0.579722552260612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10469.747     -10469.747     -10533.87      -10533.87       248.16341      248.16341      28031.813      28031.813     -1268.014      -1268.014     
     33000  -10466.561     -10466.561     -10532.307     -10532.307      254.4405       254.4405       28029.901      28029.901     -885.44851     -885.44851    
Loop time of 96.3329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.759 hours/ns, 10.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    | 95.848     | 95.848     | 95.848     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074655   | 0.074655   | 0.074655   |   0.0 |  0.08
Output  | 0.00016674 | 0.00016674 | 0.00016674 |   0.0 |  0.00
Modify  | 0.35609    | 0.35609    | 0.35609    |   0.0 |  0.37
Other   |            | 0.05412    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807409818549, Press = 1.46518418184325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10466.561     -10466.561     -10532.307     -10532.307      254.4405       254.4405       28029.901      28029.901     -885.44851     -885.44851    
     34000  -10465.518     -10465.518     -10532.449     -10532.449      259.02899      259.02899      27979.681      27979.681      1839.4377      1839.4377    
Loop time of 96.2291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.730 hours/ns, 10.392 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    | 95.744     | 95.744     | 95.744     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074339   | 0.074339   | 0.074339   |   0.0 |  0.08
Output  | 0.00017235 | 0.00017235 | 0.00017235 |   0.0 |  0.00
Modify  | 0.35643    | 0.35643    | 0.35643    |   0.0 |  0.37
Other   |            | 0.05445    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815581102061, Press = 1.48906420465077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10465.518     -10465.518     -10532.449     -10532.449      259.02899      259.02899      27979.681      27979.681      1839.4377      1839.4377    
     35000  -10467.369     -10467.369     -10532.569     -10532.569      252.33014      252.33014      27980.582      27980.582      1718.6896      1718.6896    
Loop time of 96.3187 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.755 hours/ns, 10.382 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    | 95.834     | 95.834     | 95.834     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073317   | 0.073317   | 0.073317   |   0.0 |  0.08
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.35659    | 0.35659    | 0.35659    |   0.0 |  0.37
Other   |            | 0.05428    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.787127094542, Press = -0.561931125634726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10467.369     -10467.369     -10532.569     -10532.569      252.33014      252.33014      27980.582      27980.582      1718.6896      1718.6896    
     36000  -10464.365     -10464.365     -10529.794     -10529.794      253.21774      253.21774      28016.604      28016.604      55.191722      55.191722    
Loop time of 96.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.764 hours/ns, 10.379 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.868     | 95.868     | 95.868     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073653   | 0.073653   | 0.073653   |   0.0 |  0.08
Output  | 0.00017081 | 0.00017081 | 0.00017081 |   0.0 |  0.00
Modify  | 0.35555    | 0.35555    | 0.35555    |   0.0 |  0.37
Other   |            | 0.05465    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.832165286403, Press = -1.11462066811022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10464.365     -10464.365     -10529.794     -10529.794      253.21774      253.21774      28016.604      28016.604      55.191722      55.191722    
     37000  -10465.04      -10465.04      -10533.017     -10533.017      263.07794      263.07794      28026.065      28026.065     -715.01173     -715.01173    
Loop time of 102.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.574 hours/ns, 9.721 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    | 102.34     | 102.34     | 102.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077301   | 0.077301   | 0.077301   |   0.0 |  0.08
Output  | 0.00020274 | 0.00020274 | 0.00020274 |   0.0 |  0.00
Modify  | 0.39288    | 0.39288    | 0.39288    |   0.0 |  0.38
Other   |            | 0.05791    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.802481256186, Press = -0.387579463591628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10465.04      -10465.04      -10533.017     -10533.017      263.07794      263.07794      28026.065      28026.065     -715.01173     -715.01173    
     38000  -10467.736     -10467.736     -10532.258     -10532.258      249.70692      249.70692      28021.227      28021.227     -571.92624     -571.92624    
Loop time of 112.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.769 ns/day, 31.201 hours/ns, 8.903 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    | 111.74     | 111.74     | 111.74     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083114   | 0.083114   | 0.083114   |   0.0 |  0.07
Output  | 0.00060222 | 0.00060222 | 0.00060222 |   0.0 |  0.00
Modify  | 0.44428    | 0.44428    | 0.44428    |   0.0 |  0.40
Other   |            | 0.0621     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.78937025938, Press = -0.185201377337635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10467.736     -10467.736     -10532.258     -10532.258      249.70692      249.70692      28021.227      28021.227     -571.92624     -571.92624    
     39000  -10466.535     -10466.535     -10531.653     -10531.653      252.01185      252.01185      28015.148      28015.148     -72.389296     -72.389296    
Loop time of 112.776 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.327 hours/ns, 8.867 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    | 112.19     | 112.19     | 112.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083156   | 0.083156   | 0.083156   |   0.0 |  0.07
Output  | 0.0002513  | 0.0002513  | 0.0002513  |   0.0 |  0.00
Modify  | 0.43984    | 0.43984    | 0.43984    |   0.0 |  0.39
Other   |            | 0.0622     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.72671483923, Press = 0.205989385962687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10466.535     -10466.535     -10531.653     -10531.653      252.01185      252.01185      28015.148      28015.148     -72.389296     -72.389296    
     40000  -10468.141     -10468.141     -10532.627     -10532.627      249.56854      249.56854      27989.206      27989.206      1186.1235      1186.1235    
Loop time of 112.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.768 ns/day, 31.232 hours/ns, 8.894 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    | 111.85     | 111.85     | 111.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08306    | 0.08306    | 0.08306    |   0.0 |  0.07
Output  | 0.00016882 | 0.00016882 | 0.00016882 |   0.0 |  0.00
Modify  | 0.44161    | 0.44161    | 0.44161    |   0.0 |  0.39
Other   |            | 0.06224    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.735807690981, Press = 0.167868157175959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10468.141     -10468.141     -10532.627     -10532.627      249.56854      249.56854      27989.206      27989.206      1186.1235      1186.1235    
     41000  -10466.685     -10466.685     -10532.396     -10532.396      254.30919      254.30919      27988.099      27988.099      1314.4865      1314.4865    
Loop time of 112.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.372 hours/ns, 8.854 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    | 112.35     | 112.35     | 112.35     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083276   | 0.083276   | 0.083276   |   0.0 |  0.07
Output  | 0.00016917 | 0.00016917 | 0.00016917 |   0.0 |  0.00
Modify  | 0.44428    | 0.44428    | 0.44428    |   0.0 |  0.39
Other   |            | 0.06323    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.803316035457, Press = -0.993868623589874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10466.685     -10466.685     -10532.396     -10532.396      254.30919      254.30919      27988.099      27988.099      1314.4865      1314.4865    
     42000  -10465.312     -10465.312     -10532.005     -10532.005      258.10997      258.10997      28028.971      28028.971     -799.10171     -799.10171    
Loop time of 112.6 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.278 hours/ns, 8.881 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083649   | 0.083649   | 0.083649   |   0.0 |  0.07
Output  | 0.0002185  | 0.0002185  | 0.0002185  |   0.0 |  0.00
Modify  | 0.44535    | 0.44535    | 0.44535    |   0.0 |  0.40
Other   |            | 0.06297    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.863588918765, Press = -1.84011226621186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10465.312     -10465.312     -10532.005     -10532.005      258.10997      258.10997      28028.971      28028.971     -799.10171     -799.10171    
     43000  -10466.324     -10466.324     -10532.16      -10532.16       254.79056      254.79056      28056.976      28056.976     -2517.9093     -2517.9093    
Loop time of 113.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.612 hours/ns, 8.787 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    | 113.21     | 113.21     | 113.21     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08505    | 0.08505    | 0.08505    |   0.0 |  0.07
Output  | 0.00017201 | 0.00017201 | 0.00017201 |   0.0 |  0.00
Modify  | 0.44688    | 0.44688    | 0.44688    |   0.0 |  0.39
Other   |            | 0.06337    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897810197957, Press = -0.738593762200053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10466.324     -10466.324     -10532.16      -10532.16       254.79056      254.79056      28056.976      28056.976     -2517.9093     -2517.9093    
     44000  -10469.038     -10469.038     -10533.308     -10533.308      248.72959      248.72959      28017.575      28017.575     -510.42445     -510.42445    
Loop time of 105.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.241 hours/ns, 9.499 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    | 104.73     | 104.73     | 104.73     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079203   | 0.079203   | 0.079203   |   0.0 |  0.08
Output  | 0.00016961 | 0.00016961 | 0.00016961 |   0.0 |  0.00
Modify  | 0.40509    | 0.40509    | 0.40509    |   0.0 |  0.38
Other   |            | 0.05916    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.925274776488, Press = 0.251227521577646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10469.038     -10469.038     -10533.308     -10533.308      248.72959      248.72959      28017.575      28017.575     -510.42445     -510.42445    
     45000  -10466.074     -10466.074     -10530.932     -10530.932      251.0051       251.0051       28005.186      28005.186      391.88783      391.88783    
Loop time of 99.3469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.596 hours/ns, 10.066 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    | 98.841     | 98.841     | 98.841     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074999   | 0.074999   | 0.074999   |   0.0 |  0.08
Output  | 0.00023589 | 0.00023589 | 0.00023589 |   0.0 |  0.00
Modify  | 0.37298    | 0.37298    | 0.37298    |   0.0 |  0.38
Other   |            | 0.05737    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907304647165, Press = -0.0271137810677428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10466.074     -10466.074     -10530.932     -10530.932      251.0051       251.0051       28005.186      28005.186      391.88783      391.88783    
     46000  -10468.433     -10468.433     -10532.002     -10532.002      246.01728      246.01728      28000.689      28000.689      578.71548      578.71548    
Loop time of 96.6369 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.844 hours/ns, 10.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.147     | 96.147     | 96.147     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074399   | 0.074399   | 0.074399   |   0.0 |  0.08
Output  | 0.00016923 | 0.00016923 | 0.00016923 |   0.0 |  0.00
Modify  | 0.35933    | 0.35933    | 0.35933    |   0.0 |  0.37
Other   |            | 0.05556    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856142277519, Press = -0.407922967318408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10468.433     -10468.433     -10532.002     -10532.002      246.01728      246.01728      28000.689      28000.689      578.71548      578.71548    
     47000  -10466.769     -10466.769     -10531.076     -10531.076      248.87514      248.87514      28012.4        28012.4        56.092077      56.092077    
Loop time of 96.2752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.743 hours/ns, 10.387 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    | 95.787     | 95.787     | 95.787     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07432    | 0.07432    | 0.07432    |   0.0 |  0.08
Output  | 0.00017018 | 0.00017018 | 0.00017018 |   0.0 |  0.00
Modify  | 0.35794    | 0.35794    | 0.35794    |   0.0 |  0.37
Other   |            | 0.05561    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.86138928821, Press = -0.798364616249619
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10466.769     -10466.769     -10531.076     -10531.076      248.87514      248.87514      28012.4        28012.4        56.092077      56.092077    
     48000  -10468.405     -10468.405     -10532.969     -10532.969      249.86849      249.86849      28026.708      28026.708     -1006.3583     -1006.3583    
Loop time of 99.0124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.503 hours/ns, 10.100 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    | 98.51      | 98.51      | 98.51      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075493   | 0.075493   | 0.075493   |   0.0 |  0.08
Output  | 0.00023142 | 0.00023142 | 0.00023142 |   0.0 |  0.00
Modify  | 0.36981    | 0.36981    | 0.36981    |   0.0 |  0.37
Other   |            | 0.05645    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.84207035077, Press = -0.821121767435546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10468.405     -10468.405     -10532.969     -10532.969      249.86849      249.86849      28026.708      28026.708     -1006.3583     -1006.3583    
     49000  -10467.22      -10467.22      -10531.42      -10531.42       248.464        248.464        28032.89       28032.89      -1161.8582     -1161.8582    
Loop time of 114.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.669 hours/ns, 8.771 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    | 113.42     | 113.42     | 113.42     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084642   | 0.084642   | 0.084642   |   0.0 |  0.07
Output  | 0.0002337  | 0.0002337  | 0.0002337  |   0.0 |  0.00
Modify  | 0.44482    | 0.44482    | 0.44482    |   0.0 |  0.39
Other   |            | 0.06209    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.862317115686, Press = 0.1035799653525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10467.22      -10467.22      -10531.42      -10531.42       248.464        248.464        28032.89       28032.89      -1161.8582     -1161.8582    
     50000  -10466.855     -10466.855     -10531.565     -10531.565      250.43385      250.43385      28000.649      28000.649      618.48508      618.48508    
Loop time of 114.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.766 hours/ns, 8.744 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    | 113.77     | 113.77     | 113.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084337   | 0.084337   | 0.084337   |   0.0 |  0.07
Output  | 0.00020694 | 0.00020694 | 0.00020694 |   0.0 |  0.00
Modify  | 0.44496    | 0.44496    | 0.44496    |   0.0 |  0.39
Other   |            | 0.06201    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.848207695907, Press = 0.795322935740655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10466.855     -10466.855     -10531.565     -10531.565      250.43385      250.43385      28000.649      28000.649      618.48508      618.48508    
     51000  -10468.401     -10468.401     -10532.973     -10532.973      249.89738      249.89738      27957.304      27957.304      2960.0317      2960.0317    
Loop time of 107.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.765 hours/ns, 9.332 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    | 106.6      | 106.6      | 106.6      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080445   | 0.080445   | 0.080445   |   0.0 |  0.08
Output  | 0.00020922 | 0.00020922 | 0.00020922 |   0.0 |  0.00
Modify  | 0.41635    | 0.41635    | 0.41635    |   0.0 |  0.39
Other   |            | 0.06041    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115996 ave      115996 max      115996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115996
Ave neighs/atom = 57.998
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.857184221114, Press = -0.153634067364578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10468.401     -10468.401     -10532.973     -10532.973      249.89738      249.89738      27957.304      27957.304      2960.0317      2960.0317    
     52000  -10466.258     -10466.258     -10532.389     -10532.389      255.93442      255.93442      27989.652      27989.652      1231.14        1231.14      
Loop time of 101.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.123 hours/ns, 9.877 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    | 100.73     | 100.73     | 100.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076523   | 0.076523   | 0.076523   |   0.0 |  0.08
Output  | 0.00017033 | 0.00017033 | 0.00017033 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   0.0 |  0.38
Other   |            | 0.05679    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.821260134456, Press = -1.25599584982568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10466.258     -10466.258     -10532.389     -10532.389      255.93442      255.93442      27989.652      27989.652      1231.14        1231.14      
     53000  -10467.298     -10467.298     -10533.335     -10533.335      255.57299      255.57299      28020.212      28020.212     -487.17507     -487.17507    
Loop time of 96.3601 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.767 hours/ns, 10.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    | 95.875     | 95.875     | 95.875     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073889   | 0.073889   | 0.073889   |   0.0 |  0.08
Output  | 0.00017135 | 0.00017135 | 0.00017135 |   0.0 |  0.00
Modify  | 0.3561     | 0.3561     | 0.3561     |   0.0 |  0.37
Other   |            | 0.05449    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.828219698062, Press = -0.715529880618465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10467.298     -10467.298     -10533.335     -10533.335      255.57299      255.57299      28020.212      28020.212     -487.17507     -487.17507    
     54000  -10464.632     -10464.632     -10530.278     -10530.278      254.05754      254.05754      28028.879      28028.879     -577.96538     -577.96538    
Loop time of 106.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.560 hours/ns, 9.397 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    | 105.87     | 105.87     | 105.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080868   | 0.080868   | 0.080868   |   0.0 |  0.08
Output  | 0.00024079 | 0.00024079 | 0.00024079 |   0.0 |  0.00
Modify  | 0.40968    | 0.40968    | 0.40968    |   0.0 |  0.38
Other   |            | 0.0592     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856456495832, Press = -0.248575829945348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10464.632     -10464.632     -10530.278     -10530.278      254.05754      254.05754      28028.879      28028.879     -577.96538     -577.96538    
     55000  -10463.21      -10463.21      -10530.174     -10530.174      259.15924      259.15924      28017.004      28017.004      151.18914      151.18914    
Loop time of 113.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.570 hours/ns, 8.799 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.06     | 113.06     | 113.06     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084791   | 0.084791   | 0.084791   |   0.0 |  0.07
Output  | 0.00017202 | 0.00017202 | 0.00017202 |   0.0 |  0.00
Modify  | 0.44966    | 0.44966    | 0.44966    |   0.0 |  0.40
Other   |            | 0.0627     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88034226717, Press = 0.0900861155643374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10463.21      -10463.21      -10530.174     -10530.174      259.15924      259.15924      28017.004      28017.004      151.18914      151.18914    
     56000  -10466.121     -10466.121     -10533.101     -10533.101      259.21867      259.21867      27966.12       27966.12       2661.7071      2661.7071    
Loop time of 111.581 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.774 ns/day, 30.995 hours/ns, 8.962 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    | 111        | 111        | 111        |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083202   | 0.083202   | 0.083202   |   0.0 |  0.07
Output  | 0.00020598 | 0.00020598 | 0.00020598 |   0.0 |  0.00
Modify  | 0.43713    | 0.43713    | 0.43713    |   0.0 |  0.39
Other   |            | 0.06174    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.911725482248, Press = 0.469791262916507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10466.121     -10466.121     -10533.101     -10533.101      259.21867      259.21867      27966.12       27966.12       2661.7071      2661.7071    
     57000  -10461.72      -10461.72      -10528.034     -10528.034      256.63906      256.63906      27968.011      27968.011      2897.9662      2897.9662    
Loop time of 97.9012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.195 hours/ns, 10.214 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.399     | 97.399     | 97.399     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075388   | 0.075388   | 0.075388   |   0.0 |  0.08
Output  | 0.00017234 | 0.00017234 | 0.00017234 |   0.0 |  0.00
Modify  | 0.36958    | 0.36958    | 0.36958    |   0.0 |  0.38
Other   |            | 0.05674    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.970539404109, Press = -0.985067564373976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10461.72      -10461.72      -10528.034     -10528.034      256.63906      256.63906      27968.011      27968.011      2897.9662      2897.9662    
     58000  -10467.054     -10467.054     -10531.578     -10531.578      249.71314      249.71314      28018.933      28018.933     -354.75629     -354.75629    
Loop time of 96.1592 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.711 hours/ns, 10.399 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    | 95.669     | 95.669     | 95.669     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073977   | 0.073977   | 0.073977   |   0.0 |  0.08
Output  | 0.00016777 | 0.00016777 | 0.00016777 |   0.0 |  0.00
Modify  | 0.35987    | 0.35987    | 0.35987    |   0.0 |  0.37
Other   |            | 0.0557     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.003779790073, Press = -1.17165193081461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10467.054     -10467.054     -10531.578     -10531.578      249.71314      249.71314      28018.933      28018.933     -354.75629     -354.75629    
     59000  -10464.14      -10464.14      -10531.24      -10531.24       259.68217      259.68217      28047.947      28047.947     -1924.7837     -1924.7837    
Loop time of 95.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.626 hours/ns, 10.433 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    | 95.363     | 95.363     | 95.363     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073705   | 0.073705   | 0.073705   |   0.0 |  0.08
Output  | 0.00017035 | 0.00017035 | 0.00017035 |   0.0 |  0.00
Modify  | 0.36041    | 0.36041    | 0.36041    |   0.0 |  0.38
Other   |            | 0.05518    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.026053347783, Press = -0.54117398389461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10464.14      -10464.14      -10531.24      -10531.24       259.68217      259.68217      28047.947      28047.947     -1924.7837     -1924.7837    
     60000  -10466.624     -10466.624     -10530.721     -10530.721      248.06131      248.06131      28026.45       28026.45      -671.33512     -671.33512    
Loop time of 98.5902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.386 hours/ns, 10.143 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.088     | 98.088     | 98.088     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07581    | 0.07581    | 0.07581    |   0.0 |  0.08
Output  | 0.00016714 | 0.00016714 | 0.00016714 |   0.0 |  0.00
Modify  | 0.37076    | 0.37076    | 0.37076    |   0.0 |  0.38
Other   |            | 0.05539    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       115998 ave      115998 max      115998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0