# 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.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_CostaAgrenClavaguera_2007_AlNi__MO_131642768288_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_131642768288_002#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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.961      43665.961      3453.7841      3453.7841    
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3465     -1595.3465    
Loop time of 97.0126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.891 ns/day, 26.948 hours/ns, 10.308 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    | 96.852     | 96.852     | 96.852     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02427    | 0.02427    | 0.02427    |   0.0 |  0.03
Output  | 0.00013992 | 0.00013992 | 0.00013992 |   0.0 |  0.00
Modify  | 0.12374    | 0.12374    | 0.12374    |   0.0 |  0.13
Other   |            | 0.012      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3465     -1595.3465    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26218      267.26218      44092.267      44092.267      513.45498      513.45498    
Loop time of 102.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.846 ns/day, 28.381 hours/ns, 9.788 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    | 102        | 102        | 102        |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025499   | 0.025499   | 0.025499   |   0.0 |  0.02
Output  | 0.00014841 | 0.00014841 | 0.00014841 |   0.0 |  0.00
Modify  | 0.12937    | 0.12937    | 0.12937    |   0.0 |  0.13
Other   |            | 0.0128     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534548 ave      534548 max      534548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534548
Ave neighs/atom = 133.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26218      267.26218      44092.267      44092.267      513.45498      513.45498    
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78551      359.78551    
Loop time of 102.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.847 ns/day, 28.334 hours/ns, 9.804 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    | 101.84     | 101.84     | 101.84     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023706   | 0.023706   | 0.023706   |   0.0 |  0.02
Output  | 0.00016771 | 0.00016771 | 0.00016771 |   0.0 |  0.00
Modify  | 0.1267     | 0.1267     | 0.1267     |   0.0 |  0.12
Other   |            | 0.01213    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534510 ave      534510 max      534510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534510
Ave neighs/atom = 133.6275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78551      359.78551    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.665452     -41.665452    
Loop time of 101.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.260 hours/ns, 9.829 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    | 101.57     | 101.57     | 101.57     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02352    | 0.02352    | 0.02352    |   0.0 |  0.02
Output  | 9.1672e-05 | 9.1672e-05 | 9.1672e-05 |   0.0 |  0.00
Modify  | 0.1256     | 0.1256     | 0.1256     |   0.0 |  0.12
Other   |            | 0.01221    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534636 ave      534636 max      534636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534636
Ave neighs/atom = 133.659
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.665452     -41.665452    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97815     -295.97815    
Loop time of 101.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.283 hours/ns, 9.821 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    | 101.66     | 101.66     | 101.66     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023568   | 0.023568   | 0.023568   |   0.0 |  0.02
Output  | 5.841e-05  | 5.841e-05  | 5.841e-05  |   0.0 |  0.00
Modify  | 0.12661    | 0.12661    | 0.12661    |   0.0 |  0.12
Other   |            | 0.01217    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534428 ave      534428 max      534428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534428
Ave neighs/atom = 133.607
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.611135260915, Press = -333.668973647737
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97815     -295.97815    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.479       2027.479     
Loop time of 101.977 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.847 ns/day, 28.327 hours/ns, 9.806 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    | 101.81     | 101.81     | 101.81     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023884   | 0.023884   | 0.023884   |   0.0 |  0.02
Output  | 6.2046e-05 | 6.2046e-05 | 6.2046e-05 |   0.0 |  0.00
Modify  | 0.13153    | 0.13153    | 0.13153    |   0.0 |  0.13
Other   |            | 0.01222    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534788 ave      534788 max      534788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534788
Ave neighs/atom = 133.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788199598815, Press = 6.19617509690727
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.479       2027.479     
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.974      -2174.974     
Loop time of 101.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.281 hours/ns, 9.822 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    | 101.64     | 101.64     | 101.64     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024371   | 0.024371   | 0.024371   |   0.0 |  0.02
Output  | 0.00012938 | 0.00012938 | 0.00012938 |   0.0 |  0.00
Modify  | 0.13211    | 0.13211    | 0.13211    |   0.0 |  0.13
Other   |            | 0.01237    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534538 ave      534538 max      534538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534538
Ave neighs/atom = 133.6345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017667420392, Press = 7.42247042961326
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.974      -2174.974     
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30483     -104.30483    
Loop time of 101.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.254 hours/ns, 9.832 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    | 101.55     | 101.55     | 101.55     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022961   | 0.022961   | 0.022961   |   0.0 |  0.02
Output  | 0.00012351 | 0.00012351 | 0.00012351 |   0.0 |  0.00
Modify  | 0.12953    | 0.12953    | 0.12953    |   0.0 |  0.13
Other   |            | 0.01207    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534638 ave      534638 max      534638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534638
Ave neighs/atom = 133.6595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964957625318, Press = -22.1650949564244
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30483     -104.30483    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80966      271.80966      44081.577      44081.577      584.35285      584.35285    
Loop time of 101.932 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.848 ns/day, 28.314 hours/ns, 9.810 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    | 101.76     | 101.76     | 101.76     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023662   | 0.023662   | 0.023662   |   0.0 |  0.02
Output  | 0.00012847 | 0.00012847 | 0.00012847 |   0.0 |  0.00
Modify  | 0.13124    | 0.13124    | 0.13124    |   0.0 |  0.13
Other   |            | 0.01223    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534774 ave      534774 max      534774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534774
Ave neighs/atom = 133.6935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.60252542864, Press = 1.69507059044917
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80966      271.80966      44081.577      44081.577      584.35285      584.35285    
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18346      278.18346      44139.015      44139.015     -1088.13       -1088.13      
Loop time of 102.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.847 ns/day, 28.341 hours/ns, 9.801 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    | 101.86     | 101.86     | 101.86     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023534   | 0.023534   | 0.023534   |   0.0 |  0.02
Output  | 6.2908e-05 | 6.2908e-05 | 6.2908e-05 |   0.0 |  0.00
Modify  | 0.13027    | 0.13027    | 0.13027    |   0.0 |  0.13
Other   |            | 0.01203    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534814 ave      534814 max      534814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534814
Ave neighs/atom = 133.7035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920793166193, Press = -2.82757233869583
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18346      278.18346      44139.015      44139.015     -1088.13       -1088.13      
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17785      265.17785      44083.794      44083.794      857.99246      857.99246    
Loop time of 101.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.274 hours/ns, 9.824 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    | 101.62     | 101.62     | 101.62     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023809   | 0.023809   | 0.023809   |   0.0 |  0.02
Output  | 6.0483e-05 | 6.0483e-05 | 6.0483e-05 |   0.0 |  0.00
Modify  | 0.13054    | 0.13054    | 0.13054    |   0.0 |  0.13
Other   |            | 0.01221    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534252 ave      534252 max      534252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534252
Ave neighs/atom = 133.563
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.111360631612, Press = -5.06889302265937
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17785      265.17785      44083.794      44083.794      857.99246      857.99246    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93849      272.93849      44077.693      44077.693      626.52142      626.52142    
Loop time of 101.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.240 hours/ns, 9.836 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    | 101.5      | 101.5      | 101.5      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023324   | 0.023324   | 0.023324   |   0.0 |  0.02
Output  | 0.00012875 | 0.00012875 | 0.00012875 |   0.0 |  0.00
Modify  | 0.13009    | 0.13009    | 0.13009    |   0.0 |  0.13
Other   |            | 0.012      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534508 ave      534508 max      534508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534508
Ave neighs/atom = 133.627
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.170098470884, Press = 6.06937267821909
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93849      272.93849      44077.693      44077.693      626.52142      626.52142    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69305      277.69305      44168.987      44168.987     -2879.6229     -2879.6229    
Loop time of 101.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.285 hours/ns, 9.821 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    | 101.66     | 101.66     | 101.66     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022981   | 0.022981   | 0.022981   |   0.0 |  0.02
Output  | 6.5333e-05 | 6.5333e-05 | 6.5333e-05 |   0.0 |  0.00
Modify  | 0.12966    | 0.12966    | 0.12966    |   0.0 |  0.13
Other   |            | 0.01201    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534876 ave      534876 max      534876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534876
Ave neighs/atom = 133.719
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.041612305717, Press = -4.17412516682533
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69305      277.69305      44168.987      44168.987     -2879.6229     -2879.6229    
     14000  -17520.901     -17520.901     -17661.441     -17661.441      271.88285      271.88285      44067.126      44067.126      971.64775      971.64775    
Loop time of 101.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.281 hours/ns, 9.822 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    | 101.65     | 101.65     | 101.65     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023037   | 0.023037   | 0.023037   |   0.0 |  0.02
Output  | 6.1716e-05 | 6.1716e-05 | 6.1716e-05 |   0.0 |  0.00
Modify  | 0.12946    | 0.12946    | 0.12946    |   0.0 |  0.13
Other   |            | 0.01199    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534480 ave      534480 max      534480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534480
Ave neighs/atom = 133.62
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838288233798, Press = -4.42977932062203
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17520.901     -17520.901     -17661.441     -17661.441      271.88285      271.88285      44067.126      44067.126      971.64775      971.64775    
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09628      270.09628      44096.823      44096.823      151.98748      151.98748    
Loop time of 101.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.274 hours/ns, 9.824 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    | 101.62     | 101.62     | 101.62     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023347   | 0.023347   | 0.023347   |   0.0 |  0.02
Output  | 6.1926e-05 | 6.1926e-05 | 6.1926e-05 |   0.0 |  0.00
Modify  | 0.13042    | 0.13042    | 0.13042    |   0.0 |  0.13
Other   |            | 0.01196    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5845 ave        5845 max        5845 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:       534744 ave      534744 max      534744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534744
Ave neighs/atom = 133.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824915782886, Press = 1.52585534674022
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09628      270.09628      44096.823      44096.823      151.98748      151.98748    
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.46928      279.46928      44126.699      44126.699     -1048.8236     -1048.8236    
Loop time of 101.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.266 hours/ns, 9.827 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    | 101.59     | 101.59     | 101.59     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023725   | 0.023725   | 0.023725   |   0.0 |  0.02
Output  | 6.2758e-05 | 6.2758e-05 | 6.2758e-05 |   0.0 |  0.00
Modify  | 0.13077    | 0.13077    | 0.13077    |   0.0 |  0.13
Other   |            | 0.01223    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534548 ave      534548 max      534548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534548
Ave neighs/atom = 133.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.766904967756, Press = -2.13152558871959
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17513.577     -17513.577     -17658.038     -17658.038      279.46928      279.46928      44126.699      44126.699     -1048.8236     -1048.8236    
     17000  -17520.536     -17520.536     -17660.337     -17660.337      270.45427      270.45427      44076.737      44076.737      637.58626      637.58626    
Loop time of 101.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.273 hours/ns, 9.825 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    | 101.62     | 101.62     | 101.62     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023503   | 0.023503   | 0.023503   |   0.0 |  0.02
Output  | 5.5465e-05 | 5.5465e-05 | 5.5465e-05 |   0.0 |  0.00
Modify  | 0.1301     | 0.1301     | 0.1301     |   0.0 |  0.13
Other   |            | 0.01225    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534616 ave      534616 max      534616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534616
Ave neighs/atom = 133.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.733356815772, Press = -2.641999392731
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17520.536     -17520.536     -17660.337     -17660.337      270.45427      270.45427      44076.737      44076.737      637.58626      637.58626    
     18000  -17514.952     -17514.952     -17657.569     -17657.569      275.90115      275.90115      44069.962      44069.962      1207.0984      1207.0984    
Loop time of 101.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.848 ns/day, 28.288 hours/ns, 9.820 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    | 101.67     | 101.67     | 101.67     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023567   | 0.023567   | 0.023567   |   0.0 |  0.02
Output  | 6.2337e-05 | 6.2337e-05 | 6.2337e-05 |   0.0 |  0.00
Modify  | 0.13028    | 0.13028    | 0.13028    |   0.0 |  0.13
Other   |            | 0.01212    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534732 ave      534732 max      534732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534732
Ave neighs/atom = 133.683
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.663084024398, Press = 3.64108823121798
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17514.952     -17514.952     -17657.569     -17657.569      275.90115      275.90115      44069.962      44069.962      1207.0984      1207.0984    
     19000  -17518.09      -17518.09      -17658.7       -17658.7        272.0194       272.0194       44151.408      44151.408     -2259.908      -2259.908     
Loop time of 101.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.272 hours/ns, 9.825 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    | 101.61     | 101.61     | 101.61     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023443   | 0.023443   | 0.023443   |   0.0 |  0.02
Output  | 6.2818e-05 | 6.2818e-05 | 6.2818e-05 |   0.0 |  0.00
Modify  | 0.13023    | 0.13023    | 0.13023    |   0.0 |  0.13
Other   |            | 0.01209    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534576 ave      534576 max      534576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534576
Ave neighs/atom = 133.644
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633751826738, Press = -2.1278101349298
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17518.09      -17518.09      -17658.7       -17658.7        272.0194       272.0194       44151.408      44151.408     -2259.908      -2259.908     
     20000  -17515.47      -17515.47      -17655.916     -17655.916      271.70202      271.70202      44072.301      44072.301      1323.8716      1323.8716    
Loop time of 101.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.240 hours/ns, 9.836 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    | 101.5      | 101.5      | 101.5      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023148   | 0.023148   | 0.023148   |   0.0 |  0.02
Output  | 0.00013376 | 0.00013376 | 0.00013376 |   0.0 |  0.00
Modify  | 0.12958    | 0.12958    | 0.12958    |   0.0 |  0.13
Other   |            | 0.01197    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534540 ave      534540 max      534540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534540
Ave neighs/atom = 133.635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.651144004028, Press = -1.98459375653301
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17515.47      -17515.47      -17655.916     -17655.916      271.70202      271.70202      44072.301      44072.301      1323.8716      1323.8716    
     21000  -17515.083     -17515.083     -17659.493     -17659.493      279.37137      279.37137      44105.989      44105.989     -370.1379      -370.1379     
Loop time of 101.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.251 hours/ns, 9.833 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    | 101.54     | 101.54     | 101.54     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023403   | 0.023403   | 0.023403   |   0.0 |  0.02
Output  | 6.1134e-05 | 6.1134e-05 | 6.1134e-05 |   0.0 |  0.00
Modify  | 0.13054    | 0.13054    | 0.13054    |   0.0 |  0.13
Other   |            | 0.01217    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534742 ave      534742 max      534742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534742
Ave neighs/atom = 133.6855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.580662265973, Press = 1.20253339687334
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17515.083     -17515.083     -17659.493     -17659.493      279.37137      279.37137      44105.989      44105.989     -370.1379      -370.1379     
     22000  -17518.503     -17518.503     -17659.118     -17659.118      272.02871      272.02871      44118.407      44118.407     -935.79432     -935.79432    
Loop time of 101.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.242 hours/ns, 9.836 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    | 101.51     | 101.51     | 101.51     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022728   | 0.022728   | 0.022728   |   0.0 |  0.02
Output  | 6.7015e-05 | 6.7015e-05 | 6.7015e-05 |   0.0 |  0.00
Modify  | 0.12928    | 0.12928    | 0.12928    |   0.0 |  0.13
Other   |            | 0.01187    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534582 ave      534582 max      534582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534582
Ave neighs/atom = 133.6455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.563091898626, Press = -1.55929499791109
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17518.503     -17518.503     -17659.118     -17659.118      272.02871      272.02871      44118.407      44118.407     -935.79432     -935.79432    
     23000  -17513.498     -17513.498     -17656.476     -17656.476      276.6019       276.6019       44090.866      44090.866      522.33306      522.33306    
Loop time of 101.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.252 hours/ns, 9.832 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    | 101.55     | 101.55     | 101.55     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021788   | 0.021788   | 0.021788   |   0.0 |  0.02
Output  | 7.7666e-05 | 7.7666e-05 | 7.7666e-05 |   0.0 |  0.00
Modify  | 0.12682    | 0.12682    | 0.12682    |   0.0 |  0.12
Other   |            | 0.01165    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534624 ave      534624 max      534624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534624
Ave neighs/atom = 133.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.619394735401, Press = -0.464144088393076
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17513.498     -17513.498     -17656.476     -17656.476      276.6019       276.6019       44090.866      44090.866      522.33306      522.33306    
     24000  -17520.231     -17520.231     -17659.977     -17659.977      270.34759      270.34759      44100.949      44100.949     -356.82377     -356.82377    
Loop time of 101.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.206 hours/ns, 9.848 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    | 101.38     | 101.38     | 101.38     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021676   | 0.021676   | 0.021676   |   0.0 |  0.02
Output  | 6.387e-05  | 6.387e-05  | 6.387e-05  |   0.0 |  0.00
Modify  | 0.12378    | 0.12378    | 0.12378    |   0.0 |  0.12
Other   |            | 0.01142    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534572 ave      534572 max      534572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534572
Ave neighs/atom = 133.643
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.631672721321, Press = -0.263142923225079
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17520.231     -17520.231     -17659.977     -17659.977      270.34759      270.34759      44100.949      44100.949     -356.82377     -356.82377    
     25000  -17514.089     -17514.089     -17655.302     -17655.302      273.18637      273.18637      44116.379      44116.379     -470.39155     -470.39155    
Loop time of 101.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.179 hours/ns, 9.858 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    | 101.29     | 101.29     | 101.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021699   | 0.021699   | 0.021699   |   0.0 |  0.02
Output  | 6.5914e-05 | 6.5914e-05 | 6.5914e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.12
Other   |            | 0.01114    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534612 ave      534612 max      534612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534612
Ave neighs/atom = 133.653
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.609888446605, Press = -0.909302210487836
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17514.089     -17514.089     -17655.302     -17655.302      273.18637      273.18637      44116.379      44116.379     -470.39155     -470.39155    
     26000  -17510.454     -17510.454     -17651.969     -17651.969      273.77008      273.77008      44088.237      44088.237      1085.2116      1085.2116    
Loop time of 101.354 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.154 hours/ns, 9.866 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    | 101.2      | 101.2      | 101.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021635   | 0.021635   | 0.021635   |   0.0 |  0.02
Output  | 6.9771e-05 | 6.9771e-05 | 6.9771e-05 |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.12
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534484 ave      534484 max      534484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534484
Ave neighs/atom = 133.621
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.635453603508, Press = -0.978458848752591
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17510.454     -17510.454     -17651.969     -17651.969      273.77008      273.77008      44088.237      44088.237      1085.2116      1085.2116    
     27000  -17517.067     -17517.067     -17658.904     -17658.904      274.39363      274.39363      44121.248      44121.248     -1067.1819     -1067.1819    
Loop time of 101.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.149 hours/ns, 9.868 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    | 101.18     | 101.18     | 101.18     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02159    | 0.02159    | 0.02159    |   0.0 |  0.02
Output  | 6.6054e-05 | 6.6054e-05 | 6.6054e-05 |   0.0 |  0.00
Modify  | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.12
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534360 ave      534360 max      534360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534360
Ave neighs/atom = 133.59
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.749080774239, Press = 0.679174155911649
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17517.067     -17517.067     -17658.904     -17658.904      274.39363      274.39363      44121.248      44121.248     -1067.1819     -1067.1819    
     28000  -17509.946     -17509.946     -17653.636     -17653.636      277.97661      277.97661      44125.552      44125.552     -627.70388     -627.70388    
Loop time of 101.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.190 hours/ns, 9.854 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    | 101.33     | 101.33     | 101.33     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021646   | 0.021646   | 0.021646   |   0.0 |  0.02
Output  | 6.7106e-05 | 6.7106e-05 | 6.7106e-05 |   0.0 |  0.00
Modify  | 0.12335    | 0.12335    | 0.12335    |   0.0 |  0.12
Other   |            | 0.01111    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534536 ave      534536 max      534536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534536
Ave neighs/atom = 133.634
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802819494861, Press = -2.95449475162653
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17509.946     -17509.946     -17653.636     -17653.636      277.97661      277.97661      44125.552      44125.552     -627.70388     -627.70388    
     29000  -17515.486     -17515.486     -17655.552     -17655.552      270.96747      270.96747      44051.282      44051.282      2222.2239      2222.2239    
Loop time of 101.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.217 hours/ns, 9.844 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    | 101.43     | 101.43     | 101.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.02
Output  | 7.7074e-05 | 7.7074e-05 | 7.7074e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.12
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534370 ave      534370 max      534370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534370
Ave neighs/atom = 133.5925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.840648442859, Press = 0.346870311889733
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17515.486     -17515.486     -17655.552     -17655.552      270.96747      270.96747      44051.282      44051.282      2222.2239      2222.2239    
     30000  -17521.056     -17521.056     -17659.32      -17659.32       267.48168      267.48168      44110.862      44110.862     -756.80896     -756.80896    
Loop time of 101.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.168 hours/ns, 9.862 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    | 101.25     | 101.25     | 101.25     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021646   | 0.021646   | 0.021646   |   0.0 |  0.02
Output  | 6.8679e-05 | 6.8679e-05 | 6.8679e-05 |   0.0 |  0.00
Modify  | 0.1232     | 0.1232     | 0.1232     |   0.0 |  0.12
Other   |            | 0.01105    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534584 ave      534584 max      534584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534584
Ave neighs/atom = 133.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822710201506, Press = -0.0481320584484085
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17521.056     -17521.056     -17659.32      -17659.32       267.48168      267.48168      44110.862      44110.862     -756.80896     -756.80896    
     31000  -17514.681     -17514.681     -17656.097     -17656.097      273.57976      273.57976      44099.35       44099.35       155.16049      155.16049    
Loop time of 101.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.181 hours/ns, 9.857 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    | 101.29     | 101.29     | 101.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.02
Output  | 6.952e-05  | 6.952e-05  | 6.952e-05  |   0.0 |  0.00
Modify  | 0.12328    | 0.12328    | 0.12328    |   0.0 |  0.12
Other   |            | 0.01109    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534610 ave      534610 max      534610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534610
Ave neighs/atom = 133.6525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.7875665587, Press = -0.928201612062442
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17514.681     -17514.681     -17656.097     -17656.097      273.57976      273.57976      44099.35       44099.35       155.16049      155.16049    
     32000  -17519.302     -17519.302     -17659.168     -17659.168      270.58147      270.58147      44090.739      44090.739      91.978444      91.978444    
Loop time of 101.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.234 hours/ns, 9.839 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    | 101.49     | 101.49     | 101.49     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021557   | 0.021557   | 0.021557   |   0.0 |  0.02
Output  | 5.9201e-05 | 5.9201e-05 | 5.9201e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.12
Other   |            | 0.01111    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534582 ave      534582 max      534582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534582
Ave neighs/atom = 133.6455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.745138910591, Press = -0.392150083560206
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17519.302     -17519.302     -17659.168     -17659.168      270.58147      270.58147      44090.739      44090.739      91.978444      91.978444    
     33000  -17517.657     -17517.657     -17657.946     -17657.946      271.39981      271.39981      44110.662      44110.662     -564.42106     -564.42106    
Loop time of 101.562 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.212 hours/ns, 9.846 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    | 101.41     | 101.41     | 101.41     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021604   | 0.021604   | 0.021604   |   0.0 |  0.02
Output  | 7.1915e-05 | 7.1915e-05 | 7.1915e-05 |   0.0 |  0.00
Modify  | 0.1233     | 0.1233     | 0.1233     |   0.0 |  0.12
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534658 ave      534658 max      534658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534658
Ave neighs/atom = 133.6645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77103504855, Press = -0.685994167469627
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17517.657     -17517.657     -17657.946     -17657.946      271.39981      271.39981      44110.662      44110.662     -564.42106     -564.42106    
     34000  -17517.401     -17517.401     -17657.134     -17657.134      270.32232      270.32232      44088.452      44088.452      508.39286      508.39286    
Loop time of 101.354 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.154 hours/ns, 9.866 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    | 101.2      | 101.2      | 101.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021622   | 0.021622   | 0.021622   |   0.0 |  0.02
Output  | 6.3739e-05 | 6.3739e-05 | 6.3739e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.12
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534522 ave      534522 max      534522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534522
Ave neighs/atom = 133.6305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.759504220844, Press = -0.899206095464655
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17517.401     -17517.401     -17657.134     -17657.134      270.32232      270.32232      44088.452      44088.452      508.39286      508.39286    
     35000  -17515.44      -17515.44      -17655.958     -17655.958      271.84006      271.84006      44096.197      44096.197      274.83256      274.83256    
Loop time of 101.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.204 hours/ns, 9.849 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    | 101.38     | 101.38     | 101.38     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021592   | 0.021592   | 0.021592   |   0.0 |  0.02
Output  | 6.4591e-05 | 6.4591e-05 | 6.4591e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.12
Other   |            | 0.01105    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534578 ave      534578 max      534578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534578
Ave neighs/atom = 133.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.803182250318, Press = 0.203245824346843
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17515.44      -17515.44      -17655.958     -17655.958      271.84006      271.84006      44096.197      44096.197      274.83256      274.83256    
     36000  -17515.291     -17515.291     -17656.923     -17656.923      273.99684      273.99684      44138.639      44138.639     -1500.5952     -1500.5952    
Loop time of 101.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.124 hours/ns, 9.877 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    | 101.09     | 101.09     | 101.09     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021569   | 0.021569   | 0.021569   |   0.0 |  0.02
Output  | 7.1434e-05 | 7.1434e-05 | 7.1434e-05 |   0.0 |  0.00
Modify  | 0.12361    | 0.12361    | 0.12361    |   0.0 |  0.12
Other   |            | 0.01104    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534540 ave      534540 max      534540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534540
Ave neighs/atom = 133.635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.80291818505, Press = -1.18398179222611
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17515.291     -17515.291     -17656.923     -17656.923      273.99684      273.99684      44138.639      44138.639     -1500.5952     -1500.5952    
     37000  -17520.486     -17520.486     -17659.673     -17659.673      269.26687      269.26687      44046.855      44046.855      1987.7002      1987.7002    
Loop time of 101.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.193 hours/ns, 9.853 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    | 101.34     | 101.34     | 101.34     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021642   | 0.021642   | 0.021642   |   0.0 |  0.02
Output  | 7.0082e-05 | 7.0082e-05 | 7.0082e-05 |   0.0 |  0.00
Modify  | 0.12343    | 0.12343    | 0.12343    |   0.0 |  0.12
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534528 ave      534528 max      534528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534528
Ave neighs/atom = 133.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.764360692712, Press = -1.48369705405144
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17520.486     -17520.486     -17659.673     -17659.673      269.26687      269.26687      44046.855      44046.855      1987.7002      1987.7002    
     38000  -17517.674     -17517.674     -17658.364     -17658.364      272.17526      272.17526      44097.618      44097.618     -28.600859     -28.600859    
Loop time of 101.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.282 hours/ns, 9.822 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    | 101.66     | 101.66     | 101.66     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.02
Output  | 6.3038e-05 | 6.3038e-05 | 6.3038e-05 |   0.0 |  0.00
Modify  | 0.12356    | 0.12356    | 0.12356    |   0.0 |  0.12
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534764 ave      534764 max      534764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534764
Ave neighs/atom = 133.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77448644439, Press = 1.36568437952819
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17517.674     -17517.674     -17658.364     -17658.364      272.17526      272.17526      44097.618      44097.618     -28.600859     -28.600859    
     39000  -17516.033     -17516.033     -17656.755     -17656.755      272.23488      272.23488      44116.923      44116.923     -588.35913     -588.35913    
Loop time of 101.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.202 hours/ns, 9.849 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    | 101.37     | 101.37     | 101.37     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021644   | 0.021644   | 0.021644   |   0.0 |  0.02
Output  | 7.0893e-05 | 7.0893e-05 | 7.0893e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.12
Other   |            | 0.01104    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534744 ave      534744 max      534744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534744
Ave neighs/atom = 133.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.730831102079, Press = -0.955186877919587
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17516.033     -17516.033     -17656.755     -17656.755      272.23488      272.23488      44116.923      44116.923     -588.35913     -588.35913    
     40000  -17518.628     -17518.628     -17658.465     -17658.465      270.52449      270.52449      44082.897      44082.897      549.71657      549.71657    
Loop time of 101.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.218 hours/ns, 9.844 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    | 101.43     | 101.43     | 101.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021595   | 0.021595   | 0.021595   |   0.0 |  0.02
Output  | 6.939e-05  | 6.939e-05  | 6.939e-05  |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.12
Other   |            | 0.01105    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534614 ave      534614 max      534614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534614
Ave neighs/atom = 133.6535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.734500113623, Press = -0.744921711158659
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17518.628     -17518.628     -17658.465     -17658.465      270.52449      270.52449      44082.897      44082.897      549.71657      549.71657    
     41000  -17515.665     -17515.665     -17655.662     -17655.662      270.83332      270.83332      44095.797      44095.797      353.96514      353.96514    
Loop time of 101.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.249 hours/ns, 9.833 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    | 101.54     | 101.54     | 101.54     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021602   | 0.021602   | 0.021602   |   0.0 |  0.02
Output  | 6.8538e-05 | 6.8538e-05 | 6.8538e-05 |   0.0 |  0.00
Modify  | 0.12334    | 0.12334    | 0.12334    |   0.0 |  0.12
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534676 ave      534676 max      534676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534676
Ave neighs/atom = 133.669
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.723630210374, Press = 0.312344979778904
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17515.665     -17515.665     -17655.662     -17655.662      270.83332      270.83332      44095.797      44095.797      353.96514      353.96514    
     42000  -17521.413     -17521.413     -17658.052     -17658.052      264.33665      264.33665      44130.346      44130.346     -1509.4886     -1509.4886    
Loop time of 101.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.152 hours/ns, 9.867 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    | 101.19     | 101.19     | 101.19     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021588   | 0.021588   | 0.021588   |   0.0 |  0.02
Output  | 7.1985e-05 | 7.1985e-05 | 7.1985e-05 |   0.0 |  0.00
Modify  | 0.12336    | 0.12336    | 0.12336    |   0.0 |  0.12
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534602 ave      534602 max      534602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534602
Ave neighs/atom = 133.6505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.698782437859, Press = -1.13054727766727
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17521.413     -17521.413     -17658.052     -17658.052      264.33665      264.33665      44130.346      44130.346     -1509.4886     -1509.4886    
     43000  -17514.512     -17514.512     -17654.391     -17654.391      270.60588      270.60588      44054.714      44054.714      2126.2406      2126.2406    
Loop time of 101.604 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.223 hours/ns, 9.842 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    | 101.45     | 101.45     | 101.45     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021659   | 0.021659   | 0.021659   |   0.0 |  0.02
Output  | 7.2506e-05 | 7.2506e-05 | 7.2506e-05 |   0.0 |  0.00
Modify  | 0.12341    | 0.12341    | 0.12341    |   0.0 |  0.12
Other   |            | 0.01105    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534542 ave      534542 max      534542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534542
Ave neighs/atom = 133.6355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.689818982681, Press = -1.39341942692919
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17514.512     -17514.512     -17654.391     -17654.391      270.60588      270.60588      44054.714      44054.714      2126.2406      2126.2406    
     44000  -17516.513     -17516.513     -17656.858     -17656.858      271.50653      271.50653      44100.448      44100.448     -0.76232828    -0.76232828   
Loop time of 101.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.203 hours/ns, 9.849 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    | 101.38     | 101.38     | 101.38     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021639   | 0.021639   | 0.021639   |   0.0 |  0.02
Output  | 7.0262e-05 | 7.0262e-05 | 7.0262e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.12
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534588 ave      534588 max      534588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534588
Ave neighs/atom = 133.647
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.672644902905, Press = 0.980681791730891
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17516.513     -17516.513     -17656.858     -17656.858      271.50653      271.50653      44100.448      44100.448     -0.76232828    -0.76232828   
     45000  -17520.123     -17520.123     -17658.412     -17658.412      267.52963      267.52963      44113.072      44113.072     -663.13798     -663.13798    
Loop time of 101.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.257 hours/ns, 9.831 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    | 101.57     | 101.57     | 101.57     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021585   | 0.021585   | 0.021585   |   0.0 |  0.02
Output  | 0.00012988 | 0.00012988 | 0.00012988 |   0.0 |  0.00
Modify  | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.12
Other   |            | 0.0111     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534544 ave      534544 max      534544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534544
Ave neighs/atom = 133.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.68022802286, Press = -1.25200011649408
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17520.123     -17520.123     -17658.412     -17658.412      267.52963      267.52963      44113.072      44113.072     -663.13798     -663.13798    
     46000  -17513.812     -17513.812     -17653.868     -17653.868      270.94824      270.94824      44073.737      44073.737      1422.7542      1422.7542    
Loop time of 101.528 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.202 hours/ns, 9.849 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    | 101.37     | 101.37     | 101.37     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021547   | 0.021547   | 0.021547   |   0.0 |  0.02
Output  | 6.8889e-05 | 6.8889e-05 | 6.8889e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.12
Other   |            | 0.01114    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534690 ave      534690 max      534690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534690
Ave neighs/atom = 133.6725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.664281868904, Press = -0.294022013164543
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17513.812     -17513.812     -17653.868     -17653.868      270.94824      270.94824      44073.737      44073.737      1422.7542      1422.7542    
     47000  -17510.78      -17510.78      -17653.152     -17653.152      275.4278       275.4278       44134.94       44134.94      -1015.4522     -1015.4522    
Loop time of 101.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.225 hours/ns, 9.842 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    | 101.45     | 101.45     | 101.45     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021612   | 0.021612   | 0.021612   |   0.0 |  0.02
Output  | 7.0532e-05 | 7.0532e-05 | 7.0532e-05 |   0.0 |  0.00
Modify  | 0.12356    | 0.12356    | 0.12356    |   0.0 |  0.12
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534576 ave      534576 max      534576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534576
Ave neighs/atom = 133.644
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.682694901277, Press = 0.439883089419683
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17510.78      -17510.78      -17653.152     -17653.152      275.4278       275.4278       44134.94       44134.94      -1015.4522     -1015.4522    
     48000  -17517.945     -17517.945     -17659.374     -17659.374      273.60516      273.60516      44123.753      44123.753     -1274.9235     -1274.9235    
Loop time of 101.411 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.170 hours/ns, 9.861 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    | 101.25     | 101.25     | 101.25     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021608   | 0.021608   | 0.021608   |   0.0 |  0.02
Output  | 6.5092e-05 | 6.5092e-05 | 6.5092e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.12
Other   |            | 0.01119    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534452 ave      534452 max      534452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534452
Ave neighs/atom = 133.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.727800593715, Press = -2.29320630970205
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17517.945     -17517.945     -17659.374     -17659.374      273.60516      273.60516      44123.753      44123.753     -1274.9235     -1274.9235    
     49000  -17513.042     -17513.042     -17655.533     -17655.533      275.65779      275.65779      44062.191      44062.191      1780.66        1780.66      
Loop time of 101.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.126 hours/ns, 9.876 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    | 101.1      | 101.1      | 101.1      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021592   | 0.021592   | 0.021592   |   0.0 |  0.02
Output  | 7.0021e-05 | 7.0021e-05 | 7.0021e-05 |   0.0 |  0.00
Modify  | 0.12343    | 0.12343    | 0.12343    |   0.0 |  0.12
Other   |            | 0.0111     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534554 ave      534554 max      534554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534554
Ave neighs/atom = 133.6385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.750442358146, Press = -0.162921928731331
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17513.042     -17513.042     -17655.533     -17655.533      275.65779      275.65779      44062.191      44062.191      1780.66        1780.66      
     50000  -17519.802     -17519.802     -17658.782     -17658.782      268.86644      268.86644      44105.23       44105.23      -427.51342     -427.51342    
Loop time of 101.227 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.854 ns/day, 28.119 hours/ns, 9.879 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    | 101.07     | 101.07     | 101.07     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021526   | 0.021526   | 0.021526   |   0.0 |  0.02
Output  | 6.7056e-05 | 6.7056e-05 | 6.7056e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.12
Other   |            | 0.0111     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534722 ave      534722 max      534722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534722
Ave neighs/atom = 133.6805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.753105599662, Press = -0.144892861993008
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17519.802     -17519.802     -17658.782     -17658.782      268.86644      268.86644      44105.23       44105.23      -427.51342     -427.51342    
     51000  -17514.203     -17514.203     -17657.966     -17657.966      278.11809      278.11809      44095.223      44095.223      199.15226      199.15226    
Loop time of 101.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.163 hours/ns, 9.863 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    | 101.23     | 101.23     | 101.23     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021501   | 0.021501   | 0.021501   |   0.0 |  0.02
Output  | 5.9111e-05 | 5.9111e-05 | 5.9111e-05 |   0.0 |  0.00
Modify  | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.12
Other   |            | 0.01111    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534710 ave      534710 max      534710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534710
Ave neighs/atom = 133.6775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.729543691896, Press = -0.732905864654996
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17514.203     -17514.203     -17657.966     -17657.966      278.11809      278.11809      44095.223      44095.223      199.15226      199.15226    
     52000  -17516.752     -17516.752     -17656.96      -17656.96       271.24307      271.24307      44085.901      44085.901      603.5765       603.5765     
Loop time of 101.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.142 hours/ns, 9.871 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    | 101.16     | 101.16     | 101.16     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021632   | 0.021632   | 0.021632   |   0.0 |  0.02
Output  | 7.5412e-05 | 7.5412e-05 | 7.5412e-05 |   0.0 |  0.00
Modify  | 0.12325    | 0.12325    | 0.12325    |   0.0 |  0.12
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534742 ave      534742 max      534742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534742
Ave neighs/atom = 133.6855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.724680829953, Press = 0.542234305486146
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17516.752     -17516.752     -17656.96      -17656.96       271.24307      271.24307      44085.901      44085.901      603.5765       603.5765     
     53000  -17513.781     -17513.781     -17656.63      -17656.63       276.35123      276.35123      44179.473      44179.473     -3208.6248     -3208.6248    
Loop time of 101.629 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.230 hours/ns, 9.840 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    | 101.47     | 101.47     | 101.47     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021597   | 0.021597   | 0.021597   |   0.0 |  0.02
Output  | 7.4169e-05 | 7.4169e-05 | 7.4169e-05 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.12
Other   |            | 0.01097    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534592 ave      534592 max      534592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534592
Ave neighs/atom = 133.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.7441941116, Press = -1.2221861650945
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17513.781     -17513.781     -17656.63      -17656.63       276.35123      276.35123      44179.473      44179.473     -3208.6248     -3208.6248    
     54000  -17516.765     -17516.765     -17659.157     -17659.157      275.46578      275.46578      44059.323      44059.323      1536.9707      1536.9707    
Loop time of 101.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.180 hours/ns, 9.857 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    | 101.29     | 101.29     | 101.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021692   | 0.021692   | 0.021692   |   0.0 |  0.02
Output  | 7.1314e-05 | 7.1314e-05 | 7.1314e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.12
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534462 ave      534462 max      534462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534462
Ave neighs/atom = 133.6155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.723004593623, Press = -0.640415077817093
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17516.765     -17516.765     -17659.157     -17659.157      275.46578      275.46578      44059.323      44059.323      1536.9707      1536.9707    
     55000  -17513.732     -17513.732     -17655.761     -17655.761      274.7652       274.7652       44110.979      44110.979     -277.38014     -277.38014    
Loop time of 101.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.174 hours/ns, 9.859 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    | 101.27     | 101.27     | 101.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021656   | 0.021656   | 0.021656   |   0.0 |  0.02
Output  | 7.1334e-05 | 7.1334e-05 | 7.1334e-05 |   0.0 |  0.00
Modify  | 0.12349    | 0.12349    | 0.12349    |   0.0 |  0.12
Other   |            | 0.011      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534792 ave      534792 max      534792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534792
Ave neighs/atom = 133.698
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.748647089759, Press = 0.21062823329607
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17513.732     -17513.732     -17655.761     -17655.761      274.7652       274.7652       44110.979      44110.979     -277.38014     -277.38014    
     56000  -17513.365     -17513.365     -17656.619     -17656.619      277.13612      277.13612      44114.14       44114.14      -475.0291      -475.0291     
Loop time of 101.639 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.233 hours/ns, 9.839 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    | 101.48     | 101.48     | 101.48     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021537   | 0.021537   | 0.021537   |   0.0 |  0.02
Output  | 6.6575e-05 | 6.6575e-05 | 6.6575e-05 |   0.0 |  0.00
Modify  | 0.12306    | 0.12306    | 0.12306    |   0.0 |  0.12
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534646 ave      534646 max      534646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534646
Ave neighs/atom = 133.6615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.771598426022, Press = -0.849910637942934
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17513.365     -17513.365     -17656.619     -17656.619      277.13612      277.13612      44114.14       44114.14      -475.0291      -475.0291     
     57000  -17518.207     -17518.207     -17660.357     -17660.357      274.99975      274.99975      44058.957      44058.957      1382.7787      1382.7787    
Loop time of 101.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.849 ns/day, 28.254 hours/ns, 9.832 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    | 101.56     | 101.56     | 101.56     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021465   | 0.021465   | 0.021465   |   0.0 |  0.02
Output  | 6.3289e-05 | 6.3289e-05 | 6.3289e-05 |   0.0 |  0.00
Modify  | 0.12292    | 0.12292    | 0.12292    |   0.0 |  0.12
Other   |            | 0.01068    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534662 ave      534662 max      534662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534662
Ave neighs/atom = 133.6655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.805070519945, Press = -0.135928020594671
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17518.207     -17518.207     -17660.357     -17660.357      274.99975      274.99975      44058.957      44058.957      1382.7787      1382.7787    
     58000  -17515.784     -17515.784     -17658.772     -17658.772      276.61881      276.61881      44153.307      44153.307     -2354.0936     -2354.0936    
Loop time of 101.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.185 hours/ns, 9.855 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    | 101.31     | 101.31     | 101.31     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021494   | 0.021494   | 0.021494   |   0.0 |  0.02
Output  | 7.3037e-05 | 7.3037e-05 | 7.3037e-05 |   0.0 |  0.00
Modify  | 0.12279    | 0.12279    | 0.12279    |   0.0 |  0.12
Other   |            | 0.01064    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534782 ave      534782 max      534782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534782
Ave neighs/atom = 133.6955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814186980997, Press = 0.692526366159287
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17515.784     -17515.784     -17658.772     -17658.772      276.61881      276.61881      44153.307      44153.307     -2354.0936     -2354.0936    
     59000  -17513.535     -17513.535     -17655.23      -17655.23       274.11856      274.11856      44115.169      44115.169     -476.87328     -476.87328    
Loop time of 101.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.219 hours/ns, 9.844 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    | 101.43     | 101.43     | 101.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021496   | 0.021496   | 0.021496   |   0.0 |  0.02
Output  | 7.5362e-05 | 7.5362e-05 | 7.5362e-05 |   0.0 |  0.00
Modify  | 0.12286    | 0.12286    | 0.12286    |   0.0 |  0.12
Other   |            | 0.01066    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534580 ave      534580 max      534580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534580
Ave neighs/atom = 133.645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.812316448817, Press = -1.31104195943483
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17513.535     -17513.535     -17655.23      -17655.23       274.11856      274.11856      44115.169      44115.169     -476.87328     -476.87328    
     60000  -17519.694     -17519.694     -17659.822     -17659.822      271.08679      271.08679      44064.621      44064.621      1114.9886      1114.9886    
Loop time of 101.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.204 hours/ns, 9.849 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    | 101.38     | 101.38     | 101.38     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021511   | 0.021511   | 0.021511   |   0.0 |  0.02
Output  | 6.1155e-05 | 6.1155e-05 | 6.1155e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.12
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534624 ave      534624 max      534624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534624
Ave neighs/atom = 133.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.792189207393, Press = -0.0242499507233294
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17519.694     -17519.694     -17659.822     -17659.822      271.08679      271.08679      44064.621      44064.621      1114.9886      1114.9886    
     61000  -17513.728     -17513.728     -17656.738     -17656.738      276.66118      276.66118      44125.302      44125.302     -966.86204     -966.86204    
Loop time of 101.572 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.214 hours/ns, 9.845 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    | 101.42     | 101.42     | 101.42     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021458   | 0.021458   | 0.021458   |   0.0 |  0.02
Output  | 5.5584e-05 | 5.5584e-05 | 5.5584e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.12
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534788 ave      534788 max      534788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534788
Ave neighs/atom = 133.697
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.779189728829, Press = -0.126816149611446
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17513.728     -17513.728     -17656.738     -17656.738      276.66118      276.66118      44125.302      44125.302     -966.86204     -966.86204    
     62000  -17519.185     -17519.185     -17659.409     -17659.409      271.2727       271.2727       44099.708      44099.708     -247.21735     -247.21735    
Loop time of 101.526 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.202 hours/ns, 9.850 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    | 101.37     | 101.37     | 101.37     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021456   | 0.021456   | 0.021456   |   0.0 |  0.02
Output  | 7.1084e-05 | 7.1084e-05 | 7.1084e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.12
Other   |            | 0.0106     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534596 ave      534596 max      534596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534596
Ave neighs/atom = 133.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.762842256296, Press = -0.880691334982183
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17519.185     -17519.185     -17659.409     -17659.409      271.2727       271.2727       44099.708      44099.708     -247.21735     -247.21735    
     63000  -17516.18      -17516.18      -17656.766     -17656.766      271.97336      271.97336      44072.475      44072.475      1210.1673      1210.1673    
Loop time of 101.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.219 hours/ns, 9.844 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    | 101.43     | 101.43     | 101.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021435   | 0.021435   | 0.021435   |   0.0 |  0.02
Output  | 7.1153e-05 | 7.1153e-05 | 7.1153e-05 |   0.0 |  0.00
Modify  | 0.12274    | 0.12274    | 0.12274    |   0.0 |  0.12
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534708 ave      534708 max      534708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534708
Ave neighs/atom = 133.677
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.77435786709, Press = 0.137833893638827
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17516.18      -17516.18      -17656.766     -17656.766      271.97336      271.97336      44072.475      44072.475      1210.1673      1210.1673    
     64000  -17516.606     -17516.606     -17658.909     -17658.909      275.29543      275.29543      44134.661      44134.661     -1601.666      -1601.666     
Loop time of 101.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.140 hours/ns, 9.871 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    | 101.15     | 101.15     | 101.15     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021517   | 0.021517   | 0.021517   |   0.0 |  0.02
Output  | 6.5563e-05 | 6.5563e-05 | 6.5563e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.12
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534696 ave      534696 max      534696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534696
Ave neighs/atom = 133.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.793814778066, Press = -0.330437033423714
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17516.606     -17516.606     -17658.909     -17658.909      275.29543      275.29543      44134.661      44134.661     -1601.666      -1601.666     
     65000  -17515.96      -17515.96      -17658.866     -17658.866      276.46174      276.46174      44081.668      44081.668      630.61244      630.61244    
Loop time of 101.421 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.172 hours/ns, 9.860 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    | 101.27     | 101.27     | 101.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021477   | 0.021477   | 0.021477   |   0.0 |  0.02
Output  | 7.2105e-05 | 7.2105e-05 | 7.2105e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.12
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534664 ave      534664 max      534664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534664
Ave neighs/atom = 133.666
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.801067305213, Press = -0.887009563837793
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17515.96      -17515.96      -17658.866     -17658.866      276.46174      276.46174      44081.668      44081.668      630.61244      630.61244    
     66000  -17517.913     -17517.913     -17658.74      -17658.74       272.43907      272.43907      44081.5        44081.5        614.79443      614.79443    
Loop time of 101.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.179 hours/ns, 9.858 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    | 101.29     | 101.29     | 101.29     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021498   | 0.021498   | 0.021498   |   0.0 |  0.02
Output  | 7.0281e-05 | 7.0281e-05 | 7.0281e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.12
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534656 ave      534656 max      534656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534656
Ave neighs/atom = 133.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.818372831395, Press = 0.703418021296469
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17517.913     -17517.913     -17658.74      -17658.74       272.43907      272.43907      44081.5        44081.5        614.79443      614.79443    
     67000  -17511.587     -17511.587     -17655.289     -17655.289      278.00164      278.00164      44168.875      44168.875     -2556.5228     -2556.5228    
Loop time of 101.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.212 hours/ns, 9.846 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    | 101.41     | 101.41     | 101.41     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021398   | 0.021398   | 0.021398   |   0.0 |  0.02
Output  | 6.0864e-05 | 6.0864e-05 | 6.0864e-05 |   0.0 |  0.00
Modify  | 0.12267    | 0.12267    | 0.12267    |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534782 ave      534782 max      534782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534782
Ave neighs/atom = 133.6955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848893605914, Press = -0.662423288542364
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17511.587     -17511.587     -17655.289     -17655.289      278.00164      278.00164      44168.875      44168.875     -2556.5228     -2556.5228    
     68000  -17517.259     -17517.259     -17656.816     -17656.816      269.98165      269.98165      44065.489      44065.489      1490.603       1490.603     
Loop time of 101.357 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.155 hours/ns, 9.866 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    | 101.2      | 101.2      | 101.2      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021435   | 0.021435   | 0.021435   |   0.0 |  0.02
Output  | 7.8648e-05 | 7.8648e-05 | 7.8648e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.12
Other   |            | 0.01062    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534410 ave      534410 max      534410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534410
Ave neighs/atom = 133.6025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.874749900198, Press = -0.609886522783645
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17517.259     -17517.259     -17656.816     -17656.816      269.98165      269.98165      44065.489      44065.489      1490.603       1490.603     
     69000  -17520.155     -17520.155     -17658.407     -17658.407      267.45829      267.45829      44092.08       44092.08       171.15693      171.15693    
Loop time of 101.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.227 hours/ns, 9.841 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    | 101.46     | 101.46     | 101.46     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02152    | 0.02152    | 0.02152    |   0.0 |  0.02
Output  | 6.5253e-05 | 6.5253e-05 | 6.5253e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.12
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534780 ave      534780 max      534780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534780
Ave neighs/atom = 133.695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.887739997492, Press = 0.205455807349817
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -17520.155     -17520.155     -17658.407     -17658.407      267.45829      267.45829      44092.08       44092.08       171.15693      171.15693    
     70000  -17515.298     -17515.298     -17656.357     -17656.357      272.88883      272.88883      44118.354      44118.354     -764.49537     -764.49537    
Loop time of 101.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.163 hours/ns, 9.863 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    | 101.23     | 101.23     | 101.23     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.02
Output  | 7.0733e-05 | 7.0733e-05 | 7.0733e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534680 ave      534680 max      534680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534680
Ave neighs/atom = 133.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.861201124405, Press = -0.406041914534296
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -17515.298     -17515.298     -17656.357     -17656.357      272.88883      272.88883      44118.354      44118.354     -764.49537     -764.49537    
     71000  -17517.964     -17517.964     -17658.979     -17658.979      272.80317      272.80317      44085.799      44085.799      393.20711      393.20711    
Loop time of 101.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.851 ns/day, 28.187 hours/ns, 9.855 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    | 101.32     | 101.32     | 101.32     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021452   | 0.021452   | 0.021452   |   0.0 |  0.02
Output  | 6.944e-05  | 6.944e-05  | 6.944e-05  |   0.0 |  0.00
Modify  | 0.12274    | 0.12274    | 0.12274    |   0.0 |  0.12
Other   |            | 0.01059    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534478 ave      534478 max      534478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534478
Ave neighs/atom = 133.6195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.864270014368, Press = -0.254297490897569
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -17517.964     -17517.964     -17658.979     -17658.979      272.80317      272.80317      44085.799      44085.799      393.20711      393.20711    
     72000  -17515.453     -17515.453     -17655.179     -17655.179      270.30851      270.30851      44113.837      44113.837     -366.85732     -366.85732    
Loop time of 101.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.151 hours/ns, 9.867 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    | 101.19     | 101.19     | 101.19     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021462   | 0.021462   | 0.021462   |   0.0 |  0.02
Output  | 7.456e-05  | 7.456e-05  | 7.456e-05  |   0.0 |  0.00
Modify  | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.12
Other   |            | 0.01055    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534730 ave      534730 max      534730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534730
Ave neighs/atom = 133.6825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.871504495543, Press = 0.15381684963732
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -17515.453     -17515.453     -17655.179     -17655.179      270.30851      270.30851      44113.837      44113.837     -366.85732     -366.85732    
     73000  -17519.826     -17519.826     -17659.024     -17659.024      269.2882       269.2882       44132.183      44132.183     -1531.0866     -1531.0866    
Loop time of 101.28 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.133 hours/ns, 9.874 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    | 101.13     | 101.13     | 101.13     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021394   | 0.021394   | 0.021394   |   0.0 |  0.02
Output  | 5.9492e-05 | 5.9492e-05 | 5.9492e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.12
Other   |            | 0.0105     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534520 ave      534520 max      534520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534520
Ave neighs/atom = 133.63
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.862187005605, Press = -1.13794176190494
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -17519.826     -17519.826     -17659.024     -17659.024      269.2882       269.2882       44132.183      44132.183     -1531.0866     -1531.0866    
     74000  -17506.293     -17506.293     -17650.903     -17650.903      279.75672      279.75672      44061.188      44061.188      2429.6334      2429.6334    
Loop time of 101.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.148 hours/ns, 9.868 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    | 101.18     | 101.18     | 101.18     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021442   | 0.021442   | 0.021442   |   0.0 |  0.02
Output  | 7.5411e-05 | 7.5411e-05 | 7.5411e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.12
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534602 ave      534602 max      534602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534602
Ave neighs/atom = 133.6505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.895133013608, Press = -0.117009220986677
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -17506.293     -17506.293     -17650.903     -17650.903      279.75672      279.75672      44061.188      44061.188      2429.6334      2429.6334    
     75000  -17516.344     -17516.344     -17655.452     -17655.452      269.11288      269.11288      44121.383      44121.383     -697.08635     -697.08635    
Loop time of 101.453 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.181 hours/ns, 9.857 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    | 101.3      | 101.3      | 101.3      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021501   | 0.021501   | 0.021501   |   0.0 |  0.02
Output  | 7.4289e-05 | 7.4289e-05 | 7.4289e-05 |   0.0 |  0.00
Modify  | 0.1228     | 0.1228     | 0.1228     |   0.0 |  0.12
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534460 ave      534460 max      534460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534460
Ave neighs/atom = 133.615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.918979141545, Press = 0.106288742745801
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -17516.344     -17516.344     -17655.452     -17655.452      269.11288      269.11288      44121.383      44121.383     -697.08635     -697.08635    
     76000  -17513.221     -17513.221     -17657.441     -17657.441      279.00449      279.00449      44109.47       44109.47      -302.90721     -302.90721    
Loop time of 101.257 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.127 hours/ns, 9.876 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    | 101.1      | 101.1      | 101.1      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021502   | 0.021502   | 0.021502   |   0.0 |  0.02
Output  | 0.0001507  | 0.0001507  | 0.0001507  |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.12
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534548 ave      534548 max      534548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534548
Ave neighs/atom = 133.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.9290941714, Press = -0.548057090784005
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -17513.221     -17513.221     -17657.441     -17657.441      279.00449      279.00449      44109.47       44109.47      -302.90721     -302.90721    
     77000  -17514.893     -17514.893     -17656.375     -17656.375      273.7067       273.7067       44078.979      44078.979      985.92854      985.92854    
Loop time of 101.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.853 ns/day, 28.149 hours/ns, 9.868 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    | 101.18     | 101.18     | 101.18     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021533   | 0.021533   | 0.021533   |   0.0 |  0.02
Output  | 5.6175e-05 | 5.6175e-05 | 5.6175e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.12
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534568 ave      534568 max      534568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534568
Ave neighs/atom = 133.642
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.939306338042, Press = -0.0207319286679959
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -17514.893     -17514.893     -17656.375     -17656.375      273.7067       273.7067       44078.979      44078.979      985.92854      985.92854    
     78000  -17517.622     -17517.622     -17656.846     -17656.846      269.33781      269.33781      44173.599      44173.599     -3041.4718     -3041.4718    
Loop time of 101.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.852 ns/day, 28.181 hours/ns, 9.857 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    | 101.3      | 101.3      | 101.3      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021461   | 0.021461   | 0.021461   |   0.0 |  0.02
Output  | 7.9729e-05 | 7.9729e-05 | 7.9729e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.12
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534664 ave      534664 max      534664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534664
Ave neighs/atom = 133.666
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.967618898525, Press = 0.39274801231317
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -17517.622     -17517.622     -17656.846     -17656.846      269.33781      269.33781      44173.599      44173.599     -3041.4718     -3041.4718    
     79000  -17513.264     -17513.264     -17654.02      -17654.02       272.30263      272.30263      44102.845      44102.845      235.36878      235.36878    
Loop time of 101.699 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.250 hours/ns, 9.833 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    | 101.54     | 101.54     | 101.54     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023143   | 0.023143   | 0.023143   |   0.0 |  0.02
Output  | 0.00012605 | 0.00012605 | 0.00012605 |   0.0 |  0.00
Modify  | 0.12554    | 0.12554    | 0.12554    |   0.0 |  0.12
Other   |            | 0.01084    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534370 ave      534370 max      534370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534370
Ave neighs/atom = 133.5925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.967699375971, Press = -1.03513661751396
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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -17513.264     -17513.264     -17654.02      -17654.02       272.30263      272.30263      44102.845      44102.845      235.36878      235.36878    
     80000  -17517.191     -17517.191     -17658.714     -17658.714      273.78636      273.78636      44072.715      44072.715      972.80824      972.80824    
Loop time of 101.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.850 ns/day, 28.236 hours/ns, 9.838 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    | 101.49     | 101.49     | 101.49     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022843   | 0.022843   | 0.022843   |   0.0 |  0.02
Output  | 0.0001797  | 0.0001797  | 0.0001797  |   0.0 |  0.00
Modify  | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.12
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       534578 ave      534578 max      534578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 534578
Ave neighs/atom = 133.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
44100.4910377609

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0