# 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.031088910996914*${_u_distance}
variable latticeconst_converted equal 3.031088910996914*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891099691
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.000 seconds

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

kim_interactions V

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

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


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.1293284656 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_046547823135_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10529.421     -10529.421     -10600         -10600          273.15         273.15         27848.129      27848.129      2707.0853      2707.0853    
      1000  -10453.201     -10453.201     -10529.545     -10529.545      295.45863      295.45863      28071.556      28071.556     -2538.7075     -2538.7075    
Loop time of 69.5202 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.243 ns/day, 19.311 hours/ns, 14.384 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.434     | 69.434     | 69.434     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019717   | 0.019717   | 0.019717   |   0.0 |  0.03
Output  | 0.00012781 | 0.00012781 | 0.00012781 |   0.0 |  0.00
Modify  | 0.060308   | 0.060308   | 0.060308   |   0.0 |  0.09
Other   |            | 0.006549   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       336000 ave      336000 max      336000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 336000
Ave neighs/atom = 168
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10453.201     -10453.201     -10529.545     -10529.545      295.45863      295.45863      28071.556      28071.556     -2538.7075     -2538.7075    
      2000  -10456.006     -10456.006     -10529.297     -10529.297      283.64535      283.64535      28006.911      28006.911      1063.0821      1063.0821    
Loop time of 69.6688 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.240 ns/day, 19.352 hours/ns, 14.354 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    | 69.583     | 69.583     | 69.583     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019385   | 0.019385   | 0.019385   |   0.0 |  0.03
Output  | 4.5425e-05 | 4.5425e-05 | 4.5425e-05 |   0.0 |  0.00
Modify  | 0.059708   | 0.059708   | 0.059708   |   0.0 |  0.09
Other   |            | 0.006583   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325194 ave      325194 max      325194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325194
Ave neighs/atom = 162.597
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10456.006     -10456.006     -10529.297     -10529.297      283.64535      283.64535      28006.911      28006.911      1063.0821      1063.0821    
      3000  -10455.792     -10455.792     -10526.15      -10526.15       272.29223      272.29223      28023.427      28023.427      428.61871      428.61871    
Loop time of 69.7628 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.379 hours/ns, 14.334 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    | 69.677     | 69.677     | 69.677     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019449   | 0.019449   | 0.019449   |   0.0 |  0.03
Output  | 4.3873e-05 | 4.3873e-05 | 4.3873e-05 |   0.0 |  0.00
Modify  | 0.059537   | 0.059537   | 0.059537   |   0.0 |  0.09
Other   |            | 0.006338   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325934 ave      325934 max      325934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325934
Ave neighs/atom = 162.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10455.792     -10455.792     -10526.15      -10526.15       272.29223      272.29223      28023.427      28023.427      428.61871      428.61871    
      4000  -10455.159     -10455.159     -10523.645     -10523.645      265.04482      265.04482      28036.601      28036.601     -479.80431     -479.80431    
Loop time of 69.7797 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.383 hours/ns, 14.331 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    | 69.694     | 69.694     | 69.694     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019445   | 0.019445   | 0.019445   |   0.0 |  0.03
Output  | 5.284e-05  | 5.284e-05  | 5.284e-05  |   0.0 |  0.00
Modify  | 0.059551   | 0.059551   | 0.059551   |   0.0 |  0.09
Other   |            | 0.006327   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325240 ave      325240 max      325240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325240
Ave neighs/atom = 162.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 = 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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10455.159     -10455.159     -10523.645     -10523.645      265.04482      265.04482      28036.601      28036.601     -479.80431     -479.80431    
      5000  -10455.351     -10455.351     -10523.985     -10523.985      265.62384      265.62384      28002.354      28002.354      1577.2481      1577.2481    
Loop time of 69.8225 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.395 hours/ns, 14.322 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    | 69.737     | 69.737     | 69.737     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019382   | 0.019382   | 0.019382   |   0.0 |  0.03
Output  | 3.2721e-05 | 3.2721e-05 | 3.2721e-05 |   0.0 |  0.00
Modify  | 0.059924   | 0.059924   | 0.059924   |   0.0 |  0.09
Other   |            | 0.006346   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324664 ave      324664 max      324664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324664
Ave neighs/atom = 162.332
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.643293597436, Press = -844.905130997114
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10455.351     -10455.351     -10523.985     -10523.985      265.62384      265.62384      28002.354      28002.354      1577.2481      1577.2481    
      6000  -10454.778     -10454.778     -10524.635     -10524.635      270.3539       270.3539       28068.948      28068.948     -2374.3694     -2374.3694    
Loop time of 69.7847 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.385 hours/ns, 14.330 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    | 69.697     | 69.697     | 69.697     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019468   | 0.019468   | 0.019468   |   0.0 |  0.03
Output  | 3.6018e-05 | 3.6018e-05 | 3.6018e-05 |   0.0 |  0.00
Modify  | 0.062091   | 0.062091   | 0.062091   |   0.0 |  0.09
Other   |            | 0.006411   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325300 ave      325300 max      325300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325300
Ave neighs/atom = 162.65
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.764409228326, Press = -12.1624157568014
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10454.778     -10454.778     -10524.635     -10524.635      270.3539       270.3539       28068.948      28068.948     -2374.3694     -2374.3694    
      7000  -10457.055     -10457.055     -10530.157     -10530.157      282.91311      282.91311      27977.846      27977.846      2525.3881      2525.3881    
Loop time of 69.8078 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.391 hours/ns, 14.325 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    | 69.72      | 69.72      | 69.72      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019481   | 0.019481   | 0.019481   |   0.0 |  0.03
Output  | 3.193e-05  | 3.193e-05  | 3.193e-05  |   0.0 |  0.00
Modify  | 0.061885   | 0.061885   | 0.061885   |   0.0 |  0.09
Other   |            | 0.006348   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324532 ave      324532 max      324532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324532
Ave neighs/atom = 162.266
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.111843816405, Press = -22.249144953566
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10457.055     -10457.055     -10530.157     -10530.157      282.91311      282.91311      27977.846      27977.846      2525.3881      2525.3881    
      8000  -10453.844     -10453.844     -10527.611     -10527.611      285.48697      285.48697      28055.691      28055.691     -1464.8606     -1464.8606    
Loop time of 69.8354 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.399 hours/ns, 14.319 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    | 69.748     | 69.748     | 69.748     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019405   | 0.019405   | 0.019405   |   0.0 |  0.03
Output  | 3.8242e-05 | 3.8242e-05 | 3.8242e-05 |   0.0 |  0.00
Modify  | 0.061971   | 0.061971   | 0.061971   |   0.0 |  0.09
Other   |            | 0.006362   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       326628 ave      326628 max      326628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326628
Ave neighs/atom = 163.314
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.236103655366, Press = -15.1277300955794
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10453.844     -10453.844     -10527.611     -10527.611      285.48697      285.48697      28055.691      28055.691     -1464.8606     -1464.8606    
      9000  -10456.37      -10456.37      -10526.868     -10526.868      272.83263      272.83263      28014.361      28014.361      499.7857       499.7857     
Loop time of 69.9117 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.420 hours/ns, 14.304 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    | 69.824     | 69.824     | 69.824     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019554   | 0.019554   | 0.019554   |   0.0 |  0.03
Output  | 3.3183e-05 | 3.3183e-05 | 3.3183e-05 |   0.0 |  0.00
Modify  | 0.061967   | 0.061967   | 0.061967   |   0.0 |  0.09
Other   |            | 0.006362   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325280 ave      325280 max      325280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325280
Ave neighs/atom = 162.64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.328493600463, Press = -7.40354860453028
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10456.37      -10456.37      -10526.868     -10526.868      272.83263      272.83263      28014.361      28014.361      499.7857       499.7857     
     10000  -10455.098     -10455.098     -10524.607     -10524.607      269.00728      269.00728      28033.549      28033.549     -199.35352     -199.35352    
Loop time of 70.0244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.451 hours/ns, 14.281 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    | 69.936     | 69.936     | 69.936     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019506   | 0.019506   | 0.019506   |   0.0 |  0.03
Output  | 3.1059e-05 | 3.1059e-05 | 3.1059e-05 |   0.0 |  0.00
Modify  | 0.062011   | 0.062011   | 0.062011   |   0.0 |  0.09
Other   |            | 0.00639    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325320 ave      325320 max      325320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325320
Ave neighs/atom = 162.66
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.155458949606, Press = -11.2847232665689
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10455.098     -10455.098     -10524.607     -10524.607      269.00728      269.00728      28033.549      28033.549     -199.35352     -199.35352    
     11000  -10456.157     -10456.157     -10524.29      -10524.29       263.68117      263.68117      28023.269      28023.269      360.87296      360.87296    
Loop time of 69.8244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.396 hours/ns, 14.322 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    | 69.736     | 69.736     | 69.736     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0195     | 0.0195     | 0.0195     |   0.0 |  0.03
Output  | 3.2181e-05 | 3.2181e-05 | 3.2181e-05 |   0.0 |  0.00
Modify  | 0.061982   | 0.061982   | 0.061982   |   0.0 |  0.09
Other   |            | 0.006393   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325006 ave      325006 max      325006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325006
Ave neighs/atom = 162.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.133228244591, Press = -5.35528739936411
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10456.157     -10456.157     -10524.29      -10524.29       263.68117      263.68117      28023.269      28023.269      360.87296      360.87296    
     12000  -10456.36      -10456.36      -10525.513     -10525.513      267.62814      267.62814      28026.906      28026.906      220.65137      220.65137    
Loop time of 69.7682 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.380 hours/ns, 14.333 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    | 69.681     | 69.681     | 69.681     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019374   | 0.019374   | 0.019374   |   0.0 |  0.03
Output  | 3.4334e-05 | 3.4334e-05 | 3.4334e-05 |   0.0 |  0.00
Modify  | 0.062011   | 0.062011   | 0.062011   |   0.0 |  0.09
Other   |            | 0.006092   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325100 ave      325100 max      325100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325100
Ave neighs/atom = 162.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.157801715308, Press = -8.53337983870701
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10456.36      -10456.36      -10525.513     -10525.513      267.62814      267.62814      28026.906      28026.906      220.65137      220.65137    
     13000  -10458.696     -10458.696     -10527.275     -10527.275      265.4089       265.4089       28028.688      28028.688     -295.31218     -295.31218    
Loop time of 69.8286 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.397 hours/ns, 14.321 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    | 69.741     | 69.741     | 69.741     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019347   | 0.019347   | 0.019347   |   0.0 |  0.03
Output  | 4.1869e-05 | 4.1869e-05 | 4.1869e-05 |   0.0 |  0.00
Modify  | 0.061877   | 0.061877   | 0.061877   |   0.0 |  0.09
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325458 ave      325458 max      325458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325458
Ave neighs/atom = 162.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.227083741329, Press = -4.58126164357657
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10458.696     -10458.696     -10527.275     -10527.275      265.4089       265.4089       28028.688      28028.688     -295.31218     -295.31218    
     14000  -10454.718     -10454.718     -10526.377     -10526.377      277.3284       277.3284       28014.87       28014.87       670.9679       670.9679     
Loop time of 69.9846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.440 hours/ns, 14.289 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    | 69.897     | 69.897     | 69.897     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019399   | 0.019399   | 0.019399   |   0.0 |  0.03
Output  | 7.7857e-05 | 7.7857e-05 | 7.7857e-05 |   0.0 |  0.00
Modify  | 0.061813   | 0.061813   | 0.061813   |   0.0 |  0.09
Other   |            | 0.005929   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325546 ave      325546 max      325546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325546
Ave neighs/atom = 162.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.048723584654, Press = -7.00187377934922
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10454.718     -10454.718     -10526.377     -10526.377      277.3284       277.3284       28014.87       28014.87       670.9679       670.9679     
     15000  -10455.834     -10455.834     -10526.147     -10526.147      272.12091      272.12091      28066.339      28066.339     -2159.6333     -2159.6333    
Loop time of 69.9216 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.423 hours/ns, 14.302 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    | 69.834     | 69.834     | 69.834     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019371   | 0.019371   | 0.019371   |   0.0 |  0.03
Output  | 3.9484e-05 | 3.9484e-05 | 3.9484e-05 |   0.0 |  0.00
Modify  | 0.061881   | 0.061881   | 0.061881   |   0.0 |  0.09
Other   |            | 0.005953   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325724 ave      325724 max      325724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325724
Ave neighs/atom = 162.862
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.981190965211, Press = -5.19328857458445
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10455.834     -10455.834     -10526.147     -10526.147      272.12091      272.12091      28066.339      28066.339     -2159.6333     -2159.6333    
     16000  -10455.897     -10455.897     -10522.584     -10522.584      258.08464      258.08464      27974.595      27974.595      2978.7304      2978.7304    
Loop time of 69.707 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.239 ns/day, 19.363 hours/ns, 14.346 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    | 69.62      | 69.62      | 69.62      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019415   | 0.019415   | 0.019415   |   0.0 |  0.03
Output  | 3.8262e-05 | 3.8262e-05 | 3.8262e-05 |   0.0 |  0.00
Modify  | 0.061836   | 0.061836   | 0.061836   |   0.0 |  0.09
Other   |            | 0.005936   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324798 ave      324798 max      324798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324798
Ave neighs/atom = 162.399
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.047445506141, Press = -2.65167999150832
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10455.897     -10455.897     -10522.584     -10522.584      258.08464      258.08464      27974.595      27974.595      2978.7304      2978.7304    
     17000  -10454.245     -10454.245     -10526.013     -10526.013      277.75049      277.75049      28068.331      28068.331     -2113.3974     -2113.3974    
Loop time of 69.7658 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.379 hours/ns, 14.334 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    | 69.679     | 69.679     | 69.679     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019364   | 0.019364   | 0.019364   |   0.0 |  0.03
Output  | 3.5657e-05 | 3.5657e-05 | 3.5657e-05 |   0.0 |  0.00
Modify  | 0.061904   | 0.061904   | 0.061904   |   0.0 |  0.09
Other   |            | 0.005925   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325604 ave      325604 max      325604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325604
Ave neighs/atom = 162.802
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.989364865954, Press = -6.0668133543731
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10454.245     -10454.245     -10526.013     -10526.013      277.75049      277.75049      28068.331      28068.331     -2113.3974     -2113.3974    
     18000  -10457.219     -10457.219     -10525.996     -10525.996      266.17278      266.17278      28014.198      28014.198      611.40521      611.40521    
Loop time of 69.8946 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.415 hours/ns, 14.307 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    | 69.807     | 69.807     | 69.807     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019349   | 0.019349   | 0.019349   |   0.0 |  0.03
Output  | 3.4194e-05 | 3.4194e-05 | 3.4194e-05 |   0.0 |  0.00
Modify  | 0.061862   | 0.061862   | 0.061862   |   0.0 |  0.09
Other   |            | 0.005948   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324860 ave      324860 max      324860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324860
Ave neighs/atom = 162.43
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868874146847, Press = -2.03458409456887
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10457.219     -10457.219     -10525.996     -10525.996      266.17278      266.17278      28014.198      28014.198      611.40521      611.40521    
     19000  -10454.598     -10454.598     -10524.418     -10524.418      270.21069      270.21069      28032.263      28032.263     -70.008101     -70.008101    
Loop time of 69.8659 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.407 hours/ns, 14.313 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    | 69.779     | 69.779     | 69.779     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019451   | 0.019451   | 0.019451   |   0.0 |  0.03
Output  | 3.0628e-05 | 3.0628e-05 | 3.0628e-05 |   0.0 |  0.00
Modify  | 0.061922   | 0.061922   | 0.061922   |   0.0 |  0.09
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325374 ave      325374 max      325374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325374
Ave neighs/atom = 162.687
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968200731269, Press = -4.61397090952426
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10454.598     -10454.598     -10524.418     -10524.418      270.21069      270.21069      28032.263      28032.263     -70.008101     -70.008101    
     20000  -10455.616     -10455.616     -10527.011     -10527.011      276.30675      276.30675      28032.531      28032.531     -294.36686     -294.36686    
Loop time of 69.9406 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.428 hours/ns, 14.298 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    | 69.853     | 69.853     | 69.853     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019462   | 0.019462   | 0.019462   |   0.0 |  0.03
Output  | 3.1079e-05 | 3.1079e-05 | 3.1079e-05 |   0.0 |  0.00
Modify  | 0.061966   | 0.061966   | 0.061966   |   0.0 |  0.09
Other   |            | 0.005952   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325046 ave      325046 max      325046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325046
Ave neighs/atom = 162.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.977932422398, Press = -3.69507215873507
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10455.616     -10455.616     -10527.011     -10527.011      276.30675      276.30675      28032.531      28032.531     -294.36686     -294.36686    
     21000  -10459.809     -10459.809     -10527.152     -10527.152      260.62311      260.62311      28009.924      28009.924      639.84149      639.84149    
Loop time of 69.8678 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.408 hours/ns, 14.313 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    | 69.78      | 69.78      | 69.78      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019488   | 0.019488   | 0.019488   |   0.0 |  0.03
Output  | 3.1429e-05 | 3.1429e-05 | 3.1429e-05 |   0.0 |  0.00
Modify  | 0.061914   | 0.061914   | 0.061914   |   0.0 |  0.09
Other   |            | 0.005925   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325194 ave      325194 max      325194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325194
Ave neighs/atom = 162.597
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904846686335, Press = -3.13053934615596
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10459.809     -10459.809     -10527.152     -10527.152      260.62311      260.62311      28009.924      28009.924      639.84149      639.84149    
     22000  -10454.959     -10454.959     -10525.054     -10525.054      271.27546      271.27546      28045.043      28045.043     -1017.7554     -1017.7554    
Loop time of 70.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.468 hours/ns, 14.268 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    | 69.998     | 69.998     | 69.998     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019348   | 0.019348   | 0.019348   |   0.0 |  0.03
Output  | 2.9777e-05 | 2.9777e-05 | 2.9777e-05 |   0.0 |  0.00
Modify  | 0.06193    | 0.06193    | 0.06193    |   0.0 |  0.09
Other   |            | 0.005945   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325736 ave      325736 max      325736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325736
Ave neighs/atom = 162.868
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.780050654919, Press = -3.18830571058937
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10454.959     -10454.959     -10525.054     -10525.054      271.27546      271.27546      28045.043      28045.043     -1017.7554     -1017.7554    
     23000  -10457.929     -10457.929     -10527.559     -10527.559      269.47328      269.47328      28001.496      28001.496      1183.5692      1183.5692    
Loop time of 69.9875 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.441 hours/ns, 14.288 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    | 69.9       | 69.9       | 69.9       |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019337   | 0.019337   | 0.019337   |   0.0 |  0.03
Output  | 3.706e-05  | 3.706e-05  | 3.706e-05  |   0.0 |  0.00
Modify  | 0.061929   | 0.061929   | 0.061929   |   0.0 |  0.09
Other   |            | 0.005958   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324832 ave      324832 max      324832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324832
Ave neighs/atom = 162.416
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.763149872087, Press = -1.97660750626645
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10457.929     -10457.929     -10527.559     -10527.559      269.47328      269.47328      28001.496      28001.496      1183.5692      1183.5692    
     24000  -10452.403     -10452.403     -10523.131     -10523.131      273.72527      273.72527      28056.644      28056.644     -1339.3692     -1339.3692    
Loop time of 70.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.474 hours/ns, 14.264 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    | 70.021     | 70.021     | 70.021     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019506   | 0.019506   | 0.019506   |   0.0 |  0.03
Output  | 3.0087e-05 | 3.0087e-05 | 3.0087e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.09
Other   |            | 0.005954   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325848 ave      325848 max      325848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325848
Ave neighs/atom = 162.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.68003108504, Press = -5.24191266361458
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10452.403     -10452.403     -10523.131     -10523.131      273.72527      273.72527      28056.644      28056.644     -1339.3692     -1339.3692    
     25000  -10456.441     -10456.441     -10526.685     -10526.685      271.85242      271.85242      28014.527      28014.527      556.12211      556.12211    
Loop time of 69.8143 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.393 hours/ns, 14.324 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    | 69.727     | 69.727     | 69.727     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019394   | 0.019394   | 0.019394   |   0.0 |  0.03
Output  | 3.4134e-05 | 3.4134e-05 | 3.4134e-05 |   0.0 |  0.00
Modify  | 0.061939   | 0.061939   | 0.061939   |   0.0 |  0.09
Other   |            | 0.005923   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324252 ave      324252 max      324252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324252
Ave neighs/atom = 162.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.781815897429, Press = 0.0682227094503541
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10456.441     -10456.441     -10526.685     -10526.685      271.85242      271.85242      28014.527      28014.527      556.12211      556.12211    
     26000  -10453.02      -10453.02      -10522.556     -10522.556      269.10935      269.10935      28022.364      28022.364      619.84061      619.84061    
Loop time of 69.8658 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.407 hours/ns, 14.313 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    | 69.779     | 69.779     | 69.779     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019378   | 0.019378   | 0.019378   |   0.0 |  0.03
Output  | 3.0728e-05 | 3.0728e-05 | 3.0728e-05 |   0.0 |  0.00
Modify  | 0.06198    | 0.06198    | 0.06198    |   0.0 |  0.09
Other   |            | 0.005939   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325288 ave      325288 max      325288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325288
Ave neighs/atom = 162.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.918284858238, Press = -5.19046335750181
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10453.02      -10453.02      -10522.556     -10522.556      269.10935      269.10935      28022.364      28022.364      619.84061      619.84061    
     27000  -10455.66      -10455.66      -10525.66      -10525.66       270.90941      270.90941      28036.374      28036.374     -520.66407     -520.66407    
Loop time of 69.8484 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.402 hours/ns, 14.317 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    | 69.761     | 69.761     | 69.761     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019462   | 0.019462   | 0.019462   |   0.0 |  0.03
Output  | 3.1059e-05 | 3.1059e-05 | 3.1059e-05 |   0.0 |  0.00
Modify  | 0.061893   | 0.061893   | 0.061893   |   0.0 |  0.09
Other   |            | 0.005935   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325006 ave      325006 max      325006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325006
Ave neighs/atom = 162.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.972228370468, Press = -1.37240334626589
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10455.66      -10455.66      -10525.66      -10525.66       270.90941      270.90941      28036.374      28036.374     -520.66407     -520.66407    
     28000  -10454.564     -10454.564     -10526.713     -10526.713      279.22382      279.22382      28021.767      28021.767      240.44668      240.44668    
Loop time of 69.8846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.412 hours/ns, 14.309 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    | 69.797     | 69.797     | 69.797     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019424   | 0.019424   | 0.019424   |   0.0 |  0.03
Output  | 2.8383e-05 | 2.8383e-05 | 2.8383e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.09
Other   |            | 0.005923   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325270 ave      325270 max      325270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325270
Ave neighs/atom = 162.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 = 273.064484992946, Press = -2.93038907709511
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10454.564     -10454.564     -10526.713     -10526.713      279.22382      279.22382      28021.767      28021.767      240.44668      240.44668    
     29000  -10458.953     -10458.953     -10527.496     -10527.496      265.2692       265.2692       28035.972      28035.972     -730.15524     -730.15524    
Loop time of 69.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.415 hours/ns, 14.307 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    | 69.807     | 69.807     | 69.807     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019362   | 0.019362   | 0.019362   |   0.0 |  0.03
Output  | 3.0047e-05 | 3.0047e-05 | 3.0047e-05 |   0.0 |  0.00
Modify  | 0.061882   | 0.061882   | 0.061882   |   0.0 |  0.09
Other   |            | 0.005942   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325468 ave      325468 max      325468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325468
Ave neighs/atom = 162.734
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012846486745, Press = -2.11965052714941
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10458.953     -10458.953     -10527.496     -10527.496      265.2692       265.2692       28035.972      28035.972     -730.15524     -730.15524    
     30000  -10456.387     -10456.387     -10524.894     -10524.894      265.12942      265.12942      27999.116      27999.116      1638.4544      1638.4544    
Loop time of 70.0288 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.452 hours/ns, 14.280 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    | 69.941     | 69.941     | 69.941     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01941    | 0.01941    | 0.01941    |   0.0 |  0.03
Output  | 2.9175e-05 | 2.9175e-05 | 2.9175e-05 |   0.0 |  0.00
Modify  | 0.062009   | 0.062009   | 0.062009   |   0.0 |  0.09
Other   |            | 0.005939   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325284 ave      325284 max      325284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325284
Ave neighs/atom = 162.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.89323736606, Press = -2.20935379282083
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10456.387     -10456.387     -10524.894     -10524.894      265.12942      265.12942      27999.116      27999.116      1638.4544      1638.4544    
     31000  -10455.967     -10455.967     -10526.011     -10526.011      271.0786       271.0786       28066.742      28066.742     -2213.91       -2213.91      
Loop time of 69.9792 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.439 hours/ns, 14.290 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    | 69.892     | 69.892     | 69.892     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019432   | 0.019432   | 0.019432   |   0.0 |  0.03
Output  | 3.151e-05  | 3.151e-05  | 3.151e-05  |   0.0 |  0.00
Modify  | 0.061858   | 0.061858   | 0.061858   |   0.0 |  0.09
Other   |            | 0.005953   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325368 ave      325368 max      325368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325368
Ave neighs/atom = 162.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858167275807, Press = -3.35272085780606
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10455.967     -10455.967     -10526.011     -10526.011      271.0786       271.0786       28066.742      28066.742     -2213.91       -2213.91      
     32000  -10454.774     -10454.774     -10525.284     -10525.284      272.88053      272.88053      27997.016      27997.016      1681.6535      1681.6535    
Loop time of 69.8283 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.397 hours/ns, 14.321 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    | 69.741     | 69.741     | 69.741     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019466   | 0.019466   | 0.019466   |   0.0 |  0.03
Output  | 3.1279e-05 | 3.1279e-05 | 3.1279e-05 |   0.0 |  0.00
Modify  | 0.06189    | 0.06189    | 0.06189    |   0.0 |  0.09
Other   |            | 0.005961   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324648 ave      324648 max      324648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324648
Ave neighs/atom = 162.324
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.774565079858, Press = -0.317631829612605
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10454.774     -10454.774     -10525.284     -10525.284      272.88053      272.88053      27997.016      27997.016      1681.6535      1681.6535    
     33000  -10452.641     -10452.641     -10524.387     -10524.387      277.66238      277.66238      28047.25       28047.25      -834.65915     -834.65915    
Loop time of 69.9788 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.439 hours/ns, 14.290 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    | 69.892     | 69.892     | 69.892     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019363   | 0.019363   | 0.019363   |   0.0 |  0.03
Output  | 3.16e-05   | 3.16e-05   | 3.16e-05   |   0.0 |  0.00
Modify  | 0.061936   | 0.061936   | 0.061936   |   0.0 |  0.09
Other   |            | 0.005946   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325520 ave      325520 max      325520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325520
Ave neighs/atom = 162.76
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.823853169886, Press = -3.88853379192001
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10452.641     -10452.641     -10524.387     -10524.387      277.66238      277.66238      28047.25       28047.25      -834.65915     -834.65915    
     34000  -10457.112     -10457.112     -10527.173     -10527.173      271.1415       271.1415       28027.593      28027.593     -120.7127      -120.7127     
Loop time of 69.8681 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.408 hours/ns, 14.313 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    | 69.781     | 69.781     | 69.781     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019466   | 0.019466   | 0.019466   |   0.0 |  0.03
Output  | 2.8584e-05 | 2.8584e-05 | 2.8584e-05 |   0.0 |  0.00
Modify  | 0.061969   | 0.061969   | 0.061969   |   0.0 |  0.09
Other   |            | 0.00597    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324690 ave      324690 max      324690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324690
Ave neighs/atom = 162.345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.853707451383, Press = -0.529703650279455
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10457.112     -10457.112     -10527.173     -10527.173      271.1415       271.1415       28027.593      28027.593     -120.7127      -120.7127     
     35000  -10455.159     -10455.159     -10525.801     -10525.801      273.3889       273.3889       28024.118      28024.118      220.38521      220.38521    
Loop time of 69.9604 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.433 hours/ns, 14.294 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    | 69.873     | 69.873     | 69.873     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019313   | 0.019313   | 0.019313   |   0.0 |  0.03
Output  | 3.0026e-05 | 3.0026e-05 | 3.0026e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.09
Other   |            | 0.005976   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325504 ave      325504 max      325504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325504
Ave neighs/atom = 162.752
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.850094958959, Press = -2.29785809133694
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10455.159     -10455.159     -10525.801     -10525.801      273.3889       273.3889       28024.118      28024.118      220.38521      220.38521    
     36000  -10457.405     -10457.405     -10526.824     -10526.824      268.65957      268.65957      28029.125      28029.125     -157.52381     -157.52381    
Loop time of 70.6342 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.223 ns/day, 19.621 hours/ns, 14.157 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    | 70.545     | 70.545     | 70.545     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019679   | 0.019679   | 0.019679   |   0.0 |  0.03
Output  | 3.4465e-05 | 3.4465e-05 | 3.4465e-05 |   0.0 |  0.00
Modify  | 0.063016   | 0.063016   | 0.063016   |   0.0 |  0.09
Other   |            | 0.006321   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325218 ave      325218 max      325218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325218
Ave neighs/atom = 162.609
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.816405927917, Press = -1.57352844536671
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10457.405     -10457.405     -10526.824     -10526.824      268.65957      268.65957      28029.125      28029.125     -157.52381     -157.52381    
     37000  -10454.66      -10454.66      -10527.846     -10527.846      283.23561      283.23561      28020.997      28020.997      202.23902      202.23902    
Loop time of 69.9789 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.439 hours/ns, 14.290 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    | 69.891     | 69.891     | 69.891     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019472   | 0.019472   | 0.019472   |   0.0 |  0.03
Output  | 4.261e-05  | 4.261e-05  | 4.261e-05  |   0.0 |  0.00
Modify  | 0.062274   | 0.062274   | 0.062274   |   0.0 |  0.09
Other   |            | 0.006321   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325562 ave      325562 max      325562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325562
Ave neighs/atom = 162.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.767112061627, Press = -2.21157969687026
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10454.66      -10454.66      -10527.846     -10527.846      283.23561      283.23561      28020.997      28020.997      202.23902      202.23902    
     38000  -10457.79      -10457.79      -10526.424     -10526.424      265.62266      265.62266      28048.329      28048.329     -1138.1668     -1138.1668    
Loop time of 69.8122 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.392 hours/ns, 14.324 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    | 69.725     | 69.725     | 69.725     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019161   | 0.019161   | 0.019161   |   0.0 |  0.03
Output  | 3.6589e-05 | 3.6589e-05 | 3.6589e-05 |   0.0 |  0.00
Modify  | 0.062018   | 0.062018   | 0.062018   |   0.0 |  0.09
Other   |            | 0.006311   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325508 ave      325508 max      325508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325508
Ave neighs/atom = 162.754
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.764552961728, Press = -1.88044439239914
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10457.79      -10457.79      -10526.424     -10526.424      265.62266      265.62266      28048.329      28048.329     -1138.1668     -1138.1668    
     39000  -10453.227     -10453.227     -10524.975     -10524.975      277.67001      277.67001      27992.599      27992.599      2099.2832      2099.2832    
Loop time of 70.3814 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.228 ns/day, 19.550 hours/ns, 14.208 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    | 70.292     | 70.292     | 70.292     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01982    | 0.01982    | 0.01982    |   0.0 |  0.03
Output  | 4.3141e-05 | 4.3141e-05 | 4.3141e-05 |   0.0 |  0.00
Modify  | 0.063206   | 0.063206   | 0.063206   |   0.0 |  0.09
Other   |            | 0.006317   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325046 ave      325046 max      325046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325046
Ave neighs/atom = 162.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.789398375051, Press = -1.31409590391007
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10453.227     -10453.227     -10524.975     -10524.975      277.67001      277.67001      27992.599      27992.599      2099.2832      2099.2832    
     40000  -10457.857     -10457.857     -10526.878     -10526.878      267.11944      267.11944      28053.823      28053.823     -1701.3393     -1701.3393    
Loop time of 69.9305 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.425 hours/ns, 14.300 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    | 69.843     | 69.843     | 69.843     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019326   | 0.019326   | 0.019326   |   0.0 |  0.03
Output  | 3.9735e-05 | 3.9735e-05 | 3.9735e-05 |   0.0 |  0.00
Modify  | 0.062114   | 0.062114   | 0.062114   |   0.0 |  0.09
Other   |            | 0.006307   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325774 ave      325774 max      325774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325774
Ave neighs/atom = 162.887
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.823921977284, Press = -2.4873102575562
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10457.857     -10457.857     -10526.878     -10526.878      267.11944      267.11944      28053.823      28053.823     -1701.3393     -1701.3393    
     41000  -10454.365     -10454.365     -10525.245     -10525.245      274.31256      274.31256      28005.278      28005.278      1285.9755      1285.9755    
Loop time of 70.2523 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.230 ns/day, 19.515 hours/ns, 14.234 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    | 70.164     | 70.164     | 70.164     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019627   | 0.019627   | 0.019627   |   0.0 |  0.03
Output  | 3.9775e-05 | 3.9775e-05 | 3.9775e-05 |   0.0 |  0.00
Modify  | 0.062694   | 0.062694   | 0.062694   |   0.0 |  0.09
Other   |            | 0.006279   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325162 ave      325162 max      325162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325162
Ave neighs/atom = 162.581
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.818603607384, Press = -0.496428852258172
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10454.365     -10454.365     -10525.245     -10525.245      274.31256      274.31256      28005.278      28005.278      1285.9755      1285.9755    
     42000  -10456.548     -10456.548     -10527.086     -10527.086      272.99171      272.99171      28038.382      28038.382     -700.75928     -700.75928    
Loop time of 69.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.414 hours/ns, 14.308 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    | 69.802     | 69.802     | 69.802     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019274   | 0.019274   | 0.019274   |   0.0 |  0.03
Output  | 3.0307e-05 | 3.0307e-05 | 3.0307e-05 |   0.0 |  0.00
Modify  | 0.061962   | 0.061962   | 0.061962   |   0.0 |  0.09
Other   |            | 0.006316   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325562 ave      325562 max      325562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325562
Ave neighs/atom = 162.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.833484746703, Press = -3.26005297021771
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10456.548     -10456.548     -10527.086     -10527.086      272.99171      272.99171      28038.382      28038.382     -700.75928     -700.75928    
     43000  -10455.099     -10455.099     -10524.624     -10524.624      269.07113      269.07113      28034.171      28034.171     -277.52147     -277.52147    
Loop time of 70.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.484 hours/ns, 14.256 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    | 70.056     | 70.056     | 70.056     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019465   | 0.019465   | 0.019465   |   0.0 |  0.03
Output  | 3.3043e-05 | 3.3043e-05 | 3.3043e-05 |   0.0 |  0.00
Modify  | 0.062345   | 0.062345   | 0.062345   |   0.0 |  0.09
Other   |            | 0.006293   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325302 ave      325302 max      325302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325302
Ave neighs/atom = 162.651
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864628447096, Press = 0.632246850106859
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10455.099     -10455.099     -10524.624     -10524.624      269.07113      269.07113      28034.171      28034.171     -277.52147     -277.52147    
     44000  -10454.124     -10454.124     -10523.626     -10523.626      268.97972      268.97972      27999.653      27999.653      1725.1606      1725.1606    
Loop time of 69.9567 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.432 hours/ns, 14.295 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    | 69.869     | 69.869     | 69.869     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0192     | 0.0192     | 0.0192     |   0.0 |  0.03
Output  | 3.4816e-05 | 3.4816e-05 | 3.4816e-05 |   0.0 |  0.00
Modify  | 0.061872   | 0.061872   | 0.061872   |   0.0 |  0.09
Other   |            | 0.00629    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325204 ave      325204 max      325204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325204
Ave neighs/atom = 162.602
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.942922053414, Press = -2.81699200739937
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10454.124     -10454.124     -10523.626     -10523.626      268.97972      268.97972      27999.653      27999.653      1725.1606      1725.1606    
     45000  -10453.882     -10453.882     -10525.441     -10525.441      276.94079      276.94079      28043.78       28043.78      -813.27602     -813.27602    
Loop time of 69.9572 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.433 hours/ns, 14.294 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    | 69.87      | 69.87      | 69.87      |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019215   | 0.019215   | 0.019215   |   0.0 |  0.03
Output  | 3.0959e-05 | 3.0959e-05 | 3.0959e-05 |   0.0 |  0.00
Modify  | 0.06184    | 0.06184    | 0.06184    |   0.0 |  0.09
Other   |            | 0.006306   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325442 ave      325442 max      325442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325442
Ave neighs/atom = 162.721
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.952252968102, Press = -0.99266303865273
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10453.882     -10453.882     -10525.441     -10525.441      276.94079      276.94079      28043.78       28043.78      -813.27602     -813.27602    
     46000  -10458.255     -10458.255     -10527.998     -10527.998      269.91369      269.91369      28008.608      28008.608      607.69791      607.69791    
Loop time of 70.3839 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.228 ns/day, 19.551 hours/ns, 14.208 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    | 70.295     | 70.295     | 70.295     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019494   | 0.019494   | 0.019494   |   0.0 |  0.03
Output  | 8.1163e-05 | 8.1163e-05 | 8.1163e-05 |   0.0 |  0.00
Modify  | 0.06257    | 0.06257    | 0.06257    |   0.0 |  0.09
Other   |            | 0.006328   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325016 ave      325016 max      325016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325016
Ave neighs/atom = 162.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915807861551, Press = -1.4574198222272
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10458.255     -10458.255     -10527.998     -10527.998      269.91369      269.91369      28008.608      28008.608      607.69791      607.69791    
     47000  -10454.736     -10454.736     -10525.893     -10525.893      275.3855       275.3855       28050.777      28050.777     -1267.9225     -1267.9225    
Loop time of 70.192 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.498 hours/ns, 14.247 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    | 70.103     | 70.103     | 70.103     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019952   | 0.019952   | 0.019952   |   0.0 |  0.03
Output  | 3.2431e-05 | 3.2431e-05 | 3.2431e-05 |   0.0 |  0.00
Modify  | 0.062919   | 0.062919   | 0.062919   |   0.0 |  0.09
Other   |            | 0.006256   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325724 ave      325724 max      325724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325724
Ave neighs/atom = 162.862
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.886678002264, Press = -1.46089258768986
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10454.736     -10454.736     -10525.893     -10525.893      275.3855       275.3855       28050.777      28050.777     -1267.9225     -1267.9225    
     48000  -10457.996     -10457.996     -10527.501     -10527.501      268.99233      268.99233      27985.134      27985.134      2043.4451      2043.4451    
Loop time of 70.5647 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.224 ns/day, 19.601 hours/ns, 14.171 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    | 70.475     | 70.475     | 70.475     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019936   | 0.019936   | 0.019936   |   0.0 |  0.03
Output  | 3.6219e-05 | 3.6219e-05 | 3.6219e-05 |   0.0 |  0.00
Modify  | 0.063214   | 0.063214   | 0.063214   |   0.0 |  0.09
Other   |            | 0.006317   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325092 ave      325092 max      325092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325092
Ave neighs/atom = 162.546
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869057302649, Press = -0.783932496563724
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10457.996     -10457.996     -10527.501     -10527.501      268.99233      268.99233      27985.134      27985.134      2043.4451      2043.4451    
     49000  -10452.951     -10452.951     -10525.267     -10525.267      279.8719       279.8719       28065.971      28065.971     -2001.4064     -2001.4064    
Loop time of 70.2066 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.502 hours/ns, 14.244 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    | 70.118     | 70.118     | 70.118     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019549   | 0.019549   | 0.019549   |   0.0 |  0.03
Output  | 8.0392e-05 | 8.0392e-05 | 8.0392e-05 |   0.0 |  0.00
Modify  | 0.062568   | 0.062568   | 0.062568   |   0.0 |  0.09
Other   |            | 0.006286   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       326006 ave      326006 max      326006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326006
Ave neighs/atom = 163.003
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87601201235, Press = -2.48209712973551
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10452.951     -10452.951     -10525.267     -10525.267      279.8719       279.8719       28065.971      28065.971     -2001.4064     -2001.4064    
     50000  -10456.583     -10456.583     -10525.436     -10525.436      266.46842      266.46842      28012.872      28012.872      832.28701      832.28701    
Loop time of 70.0971 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.471 hours/ns, 14.266 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    | 70.008     | 70.008     | 70.008     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020063   | 0.020063   | 0.020063   |   0.0 |  0.03
Output  | 3.0738e-05 | 3.0738e-05 | 3.0738e-05 |   0.0 |  0.00
Modify  | 0.062724   | 0.062724   | 0.062724   |   0.0 |  0.09
Other   |            | 0.006327   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324614 ave      324614 max      324614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324614
Ave neighs/atom = 162.307
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.924405381436, Press = -0.0809955177272005
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10456.583     -10456.583     -10525.436     -10525.436      266.46842      266.46842      28012.872      28012.872      832.28701      832.28701    
     51000  -10455.22      -10455.22      -10526.168     -10526.168      274.57669      274.57669      28027.657      28027.657     -63.284581     -63.284581    
Loop time of 70.1874 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.497 hours/ns, 14.248 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    | 70.099     | 70.099     | 70.099     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019714   | 0.019714   | 0.019714   |   0.0 |  0.03
Output  | 3.5307e-05 | 3.5307e-05 | 3.5307e-05 |   0.0 |  0.00
Modify  | 0.06257    | 0.06257    | 0.06257    |   0.0 |  0.09
Other   |            | 0.006282   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325550 ave      325550 max      325550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325550
Ave neighs/atom = 162.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.958766721887, Press = -1.87380092839725
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10455.22      -10455.22      -10526.168     -10526.168      274.57669      274.57669      28027.657      28027.657     -63.284581     -63.284581    
     52000  -10456.553     -10456.553     -10525.335     -10525.335      266.19266      266.19266      28027.832      28027.832     -127.65556     -127.65556    
Loop time of 70.0736 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.465 hours/ns, 14.271 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    | 69.985     | 69.985     | 69.985     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019744   | 0.019744   | 0.019744   |   0.0 |  0.03
Output  | 5.9803e-05 | 5.9803e-05 | 5.9803e-05 |   0.0 |  0.00
Modify  | 0.062585   | 0.062585   | 0.062585   |   0.0 |  0.09
Other   |            | 0.006288   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325500 ave      325500 max      325500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325500
Ave neighs/atom = 162.75
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.015460828143, Press = -0.895125742814225
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10456.553     -10456.553     -10525.335     -10525.335      266.19266      266.19266      28027.832      28027.832     -127.65556     -127.65556    
     53000  -10453.907     -10453.907     -10525.199     -10525.199      275.90745      275.90745      28019.739      28019.739      553.05115      553.05115    
Loop time of 70.2798 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.229 ns/day, 19.522 hours/ns, 14.229 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    | 70.191     | 70.191     | 70.191     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019689   | 0.019689   | 0.019689   |   0.0 |  0.03
Output  | 3.204e-05  | 3.204e-05  | 3.204e-05  |   0.0 |  0.00
Modify  | 0.062759   | 0.062759   | 0.062759   |   0.0 |  0.09
Other   |            | 0.006259   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325256 ave      325256 max      325256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325256
Ave neighs/atom = 162.628
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.028311961705, Press = -1.53657286734793
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10453.907     -10453.907     -10525.199     -10525.199      275.90745      275.90745      28019.739      28019.739      553.05115      553.05115    
     54000  -10456.063     -10456.063     -10526.206     -10526.206      271.46118      271.46118      28034.199      28034.199     -500.59362     -500.59362    
Loop time of 70.2887 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.229 ns/day, 19.525 hours/ns, 14.227 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    | 70.2       | 70.2       | 70.2       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019531   | 0.019531   | 0.019531   |   0.0 |  0.03
Output  | 3.166e-05  | 3.166e-05  | 3.166e-05  |   0.0 |  0.00
Modify  | 0.062477   | 0.062477   | 0.062477   |   0.0 |  0.09
Other   |            | 0.006283   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325480 ave      325480 max      325480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325480
Ave neighs/atom = 162.74
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.029599283811, Press = -1.12744229510013
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10456.063     -10456.063     -10526.206     -10526.206      271.46118      271.46118      28034.199      28034.199     -500.59362     -500.59362    
     55000  -10454.596     -10454.596     -10524.75      -10524.75       271.50206      271.50206      28017.442      28017.442      556.10064      556.10064    
Loop time of 70.3183 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.229 ns/day, 19.533 hours/ns, 14.221 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    | 70.23      | 70.23      | 70.23      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01953    | 0.01953    | 0.01953    |   0.0 |  0.03
Output  | 8.0643e-05 | 8.0643e-05 | 8.0643e-05 |   0.0 |  0.00
Modify  | 0.062331   | 0.062331   | 0.062331   |   0.0 |  0.09
Other   |            | 0.006276   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325334 ave      325334 max      325334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325334
Ave neighs/atom = 162.667
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.999599741534, Press = -1.16406051288777
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10454.596     -10454.596     -10524.75      -10524.75       271.50206      271.50206      28017.442      28017.442      556.10064      556.10064    
     56000  -10458.898     -10458.898     -10527.147     -10527.147      264.13123      264.13123      28034.252      28034.252     -629.93443     -629.93443    
Loop time of 69.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.431 hours/ns, 14.296 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    | 69.863     | 69.863     | 69.863     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019291   | 0.019291   | 0.019291   |   0.0 |  0.03
Output  | 3.4184e-05 | 3.4184e-05 | 3.4184e-05 |   0.0 |  0.00
Modify  | 0.061944   | 0.061944   | 0.061944   |   0.0 |  0.09
Other   |            | 0.006284   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325328 ave      325328 max      325328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325328
Ave neighs/atom = 162.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.970840270268, Press = -1.64998015985345
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10458.898     -10458.898     -10527.147     -10527.147      264.13123      264.13123      28034.252      28034.252     -629.93443     -629.93443    
     57000  -10454.06      -10454.06      -10526.379     -10526.379      279.88203      279.88203      28013.709      28013.709      769.00349      769.00349    
Loop time of 70.3314 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.228 ns/day, 19.536 hours/ns, 14.218 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    | 70.241     | 70.241     | 70.241     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020263   | 0.020263   | 0.020263   |   0.0 |  0.03
Output  | 3.0578e-05 | 3.0578e-05 | 3.0578e-05 |   0.0 |  0.00
Modify  | 0.063368   | 0.063368   | 0.063368   |   0.0 |  0.09
Other   |            | 0.006328   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325390 ave      325390 max      325390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325390
Ave neighs/atom = 162.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.942205154749, Press = -0.10716540859478
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10454.06      -10454.06      -10526.379     -10526.379      279.88203      279.88203      28013.709      28013.709      769.00349      769.00349    
     58000  -10455.012     -10455.012     -10526.289     -10526.289      275.84949      275.84949      28023.794      28023.794      244.1324       244.1324     
Loop time of 70.0606 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.461 hours/ns, 14.273 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    | 69.971     | 69.971     | 69.971     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.020086   | 0.020086   | 0.020086   |   0.0 |  0.03
Output  | 9.8596e-05 | 9.8596e-05 | 9.8596e-05 |   0.0 |  0.00
Modify  | 0.062856   | 0.062856   | 0.062856   |   0.0 |  0.09
Other   |            | 0.006305   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325624 ave      325624 max      325624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325624
Ave neighs/atom = 162.812
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934733668008, Press = -2.43703842258457
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10455.012     -10455.012     -10526.289     -10526.289      275.84949      275.84949      28023.794      28023.794      244.1324       244.1324     
     59000  -10455.394     -10455.394     -10525.573     -10525.573      271.60031      271.60031      28041.048      28041.048     -822.98434     -822.98434    
Loop time of 69.8184 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.237 ns/day, 19.394 hours/ns, 14.323 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    | 69.731     | 69.731     | 69.731     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019303   | 0.019303   | 0.019303   |   0.0 |  0.03
Output  | 3.163e-05  | 3.163e-05  | 3.163e-05  |   0.0 |  0.00
Modify  | 0.062068   | 0.062068   | 0.062068   |   0.0 |  0.09
Other   |            | 0.006249   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325610 ave      325610 max      325610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325610
Ave neighs/atom = 162.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.951297385629, Press = -0.43478572752014
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10455.394     -10455.394     -10525.573     -10525.573      271.60031      271.60031      28041.048      28041.048     -822.98434     -822.98434    
     60000  -10455.967     -10455.967     -10524.838     -10524.838      266.53833      266.53833      28010.266      28010.266      919.94401      919.94401    
Loop time of 70.3089 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.229 ns/day, 19.530 hours/ns, 14.223 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    | 70.221     | 70.221     | 70.221     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01956    | 0.01956    | 0.01956    |   0.0 |  0.03
Output  | 6.928e-05  | 6.928e-05  | 6.928e-05  |   0.0 |  0.00
Modify  | 0.062212   | 0.062212   | 0.062212   |   0.0 |  0.09
Other   |            | 0.006044   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325082 ave      325082 max      325082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325082
Ave neighs/atom = 162.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941682356397, Press = -1.35856686109953
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10455.967     -10455.967     -10524.838     -10524.838      266.53833      266.53833      28010.266      28010.266      919.94401      919.94401    
     61000  -10453.528     -10453.528     -10524.348     -10524.348      274.08174      274.08174      28036.724      28036.724     -379.49176     -379.49176    
Loop time of 70.0484 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.458 hours/ns, 14.276 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    | 69.96      | 69.96      | 69.96      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019692   | 0.019692   | 0.019692   |   0.0 |  0.03
Output  | 3.744e-05  | 3.744e-05  | 3.744e-05  |   0.0 |  0.00
Modify  | 0.062359   | 0.062359   | 0.062359   |   0.0 |  0.09
Other   |            | 0.005971   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325526 ave      325526 max      325526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325526
Ave neighs/atom = 162.763
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.938251348426, Press = -1.13135825593681
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10453.528     -10453.528     -10524.348     -10524.348      274.08174      274.08174      28036.724      28036.724     -379.49176     -379.49176    
     62000  -10455.888     -10455.888     -10525.724     -10525.724      270.27214      270.27214      28015.93       28015.93       622.73504      622.73504    
Loop time of 70.2123 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.503 hours/ns, 14.243 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    | 70.123     | 70.123     | 70.123     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019954   | 0.019954   | 0.019954   |   0.0 |  0.03
Output  | 3.0527e-05 | 3.0527e-05 | 3.0527e-05 |   0.0 |  0.00
Modify  | 0.062888   | 0.062888   | 0.062888   |   0.0 |  0.09
Other   |            | 0.006334   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324836 ave      324836 max      324836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324836
Ave neighs/atom = 162.418
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.973587322993, Press = -1.18130425142192
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10455.888     -10455.888     -10525.724     -10525.724      270.27214      270.27214      28015.93       28015.93       622.73504      622.73504    
     63000  -10452.977     -10452.977     -10525.641     -10525.641      281.21521      281.21521      28043.909      28043.909     -900.88979     -900.88979    
Loop time of 69.9468 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.430 hours/ns, 14.297 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    | 69.858     | 69.858     | 69.858     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019643   | 0.019643   | 0.019643   |   0.0 |  0.03
Output  | 3.2571e-05 | 3.2571e-05 | 3.2571e-05 |   0.0 |  0.00
Modify  | 0.062357   | 0.062357   | 0.062357   |   0.0 |  0.09
Other   |            | 0.006281   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325664 ave      325664 max      325664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325664
Ave neighs/atom = 162.832
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990243514994, Press = -1.23369302208973
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10452.977     -10452.977     -10525.641     -10525.641      281.21521      281.21521      28043.909      28043.909     -900.88979     -900.88979    
     64000  -10456.6       -10456.6       -10526.921     -10526.921      272.14975      272.14975      28012.014      28012.014      613.82493      613.82493    
Loop time of 70.0674 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.463 hours/ns, 14.272 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    | 69.978     | 69.978     | 69.978     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019909   | 0.019909   | 0.019909   |   0.0 |  0.03
Output  | 3.4235e-05 | 3.4235e-05 | 3.4235e-05 |   0.0 |  0.00
Modify  | 0.063008   | 0.063008   | 0.063008   |   0.0 |  0.09
Other   |            | 0.006306   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325098 ave      325098 max      325098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325098
Ave neighs/atom = 162.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.992321075107, Press = -0.88802538729934
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10456.6       -10456.6       -10526.921     -10526.921      272.14975      272.14975      28012.014      28012.014      613.82493      613.82493    
     65000  -10453.884     -10453.884     -10526.352     -10526.352      280.46021      280.46021      28031.083      28031.083     -273.66857     -273.66857    
Loop time of 70.1625 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.231 ns/day, 19.490 hours/ns, 14.253 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    | 70.074     | 70.074     | 70.074     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019818   | 0.019818   | 0.019818   |   0.0 |  0.03
Output  | 6.7468e-05 | 6.7468e-05 | 6.7468e-05 |   0.0 |  0.00
Modify  | 0.06246    | 0.06246    | 0.06246    |   0.0 |  0.09
Other   |            | 0.00631    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325564 ave      325564 max      325564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325564
Ave neighs/atom = 162.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.987594580908, Press = -1.69869771310394
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10453.884     -10453.884     -10526.352     -10526.352      280.46021      280.46021      28031.083      28031.083     -273.66857     -273.66857    
     66000  -10456.127     -10456.127     -10526.271     -10526.271      271.46456      271.46456      28034.058      28034.058     -433.65508     -433.65508    
Loop time of 70.0521 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.459 hours/ns, 14.275 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    | 69.964     | 69.964     | 69.964     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019592   | 0.019592   | 0.019592   |   0.0 |  0.03
Output  | 3.6579e-05 | 3.6579e-05 | 3.6579e-05 |   0.0 |  0.00
Modify  | 0.062393   | 0.062393   | 0.062393   |   0.0 |  0.09
Other   |            | 0.006272   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325382 ave      325382 max      325382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325382
Ave neighs/atom = 162.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.990478332263, Press = -0.413774441902781
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10456.127     -10456.127     -10526.271     -10526.271      271.46456      271.46456      28034.058      28034.058     -433.65508     -433.65508    
     67000  -10453.165     -10453.165     -10523.8       -10523.8        273.36509      273.36509      28007.058      28007.058      1320.2484      1320.2484    
Loop time of 70.0062 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.446 hours/ns, 14.284 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    | 69.918     | 69.918     | 69.918     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019619   | 0.019619   | 0.019619   |   0.0 |  0.03
Output  | 9.3857e-05 | 9.3857e-05 | 9.3857e-05 |   0.0 |  0.00
Modify  | 0.062499   | 0.062499   | 0.062499   |   0.0 |  0.09
Other   |            | 0.006331   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325298 ave      325298 max      325298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325298
Ave neighs/atom = 162.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.98402925384, Press = -1.72786281504412
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10453.165     -10453.165     -10523.8       -10523.8        273.36509      273.36509      28007.058      28007.058      1320.2484      1320.2484    
     68000  -10454.957     -10454.957     -10526.815     -10526.815      278.0953       278.0953       28062.966      28062.966     -2155.4848     -2155.4848    
Loop time of 70.3739 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.228 ns/day, 19.548 hours/ns, 14.210 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    | 70.285     | 70.285     | 70.285     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01994    | 0.01994    | 0.01994    |   0.0 |  0.03
Output  | 3.6058e-05 | 3.6058e-05 | 3.6058e-05 |   0.0 |  0.00
Modify  | 0.062899   | 0.062899   | 0.062899   |   0.0 |  0.09
Other   |            | 0.006312   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325316 ave      325316 max      325316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325316
Ave neighs/atom = 162.658
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.997701678097, Press = -0.914601869688361
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10454.957     -10454.957     -10526.815     -10526.815      278.0953       278.0953       28062.966      28062.966     -2155.4848     -2155.4848    
     69000  -10452.353     -10452.353     -10524.827     -10524.827      280.47879      280.47879      27949.321      27949.321      4512.4004      4512.4004    
Loop time of 70.0797 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.467 hours/ns, 14.269 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    | 69.991     | 69.991     | 69.991     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019531   | 0.019531   | 0.019531   |   0.0 |  0.03
Output  | 0.0001103  | 0.0001103  | 0.0001103  |   0.0 |  0.00
Modify  | 0.062461   | 0.062461   | 0.062461   |   0.0 |  0.09
Other   |            | 0.006298   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324654 ave      324654 max      324654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324654
Ave neighs/atom = 162.327
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.033632395676, Press = -0.632014353278193
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10452.353     -10452.353     -10524.827     -10524.827      280.47879      280.47879      27949.321      27949.321      4512.4004      4512.4004    
     70000  -10454.402     -10454.402     -10525.615     -10525.615      275.6025       275.6025       28067.848      28067.848     -2277.3951     -2277.3951    
Loop time of 70.3841 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.228 ns/day, 19.551 hours/ns, 14.208 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    | 70.296     | 70.296     | 70.296     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019509   | 0.019509   | 0.019509   |   0.0 |  0.03
Output  | 3.3904e-05 | 3.3904e-05 | 3.3904e-05 |   0.0 |  0.00
Modify  | 0.062396   | 0.062396   | 0.062396   |   0.0 |  0.09
Other   |            | 0.006277   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       326284 ave      326284 max      326284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326284
Ave neighs/atom = 163.142
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.022623846275, Press = -1.45952000298679
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10454.402     -10454.402     -10525.615     -10525.615      275.6025       275.6025       28067.848      28067.848     -2277.3951     -2277.3951    
     71000  -10455.041     -10455.041     -10525.305     -10525.305      271.92998      271.92998      28011.62       28011.62       810.91887      810.91887    
Loop time of 69.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.410 hours/ns, 14.311 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    | 69.789     | 69.789     | 69.789     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019368   | 0.019368   | 0.019368   |   0.0 |  0.03
Output  | 3.4686e-05 | 3.4686e-05 | 3.4686e-05 |   0.0 |  0.00
Modify  | 0.062049   | 0.062049   | 0.062049   |   0.0 |  0.09
Other   |            | 0.006236   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324588 ave      324588 max      324588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324588
Ave neighs/atom = 162.294
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.00177210148, Press = -0.605083397495619
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10455.041     -10455.041     -10525.305     -10525.305      271.92998      271.92998      28011.62       28011.62       810.91887      810.91887    
     72000  -10457.038     -10457.038     -10526.748     -10526.748      269.78392      269.78392      28027.743      28027.743     -292.7668      -292.7668     
Loop time of 69.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.238 ns/day, 19.383 hours/ns, 14.331 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    | 69.69      | 69.69      | 69.69      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019195   | 0.019195   | 0.019195   |   0.0 |  0.03
Output  | 3.1981e-05 | 3.1981e-05 | 3.1981e-05 |   0.0 |  0.00
Modify  | 0.061738   | 0.061738   | 0.061738   |   0.0 |  0.09
Other   |            | 0.006321   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325648 ave      325648 max      325648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325648
Ave neighs/atom = 162.824
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9920614853, Press = -1.35218481127458
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10457.038     -10457.038     -10526.748     -10526.748      269.78392      269.78392      28027.743      28027.743     -292.7668      -292.7668     
     73000  -10453.873     -10453.873     -10524.789     -10524.789      274.4549       274.4549       28038.365      28038.365     -462.72011     -462.72011    
Loop time of 70.2605 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.230 ns/day, 19.517 hours/ns, 14.233 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    | 70.172     | 70.172     | 70.172     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019458   | 0.019458   | 0.019458   |   0.0 |  0.03
Output  | 9.7354e-05 | 9.7354e-05 | 9.7354e-05 |   0.0 |  0.00
Modify  | 0.062581   | 0.062581   | 0.062581   |   0.0 |  0.09
Other   |            | 0.006309   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325182 ave      325182 max      325182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325182
Ave neighs/atom = 162.591
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990494773895, Press = -0.293733367382334
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10453.873     -10453.873     -10524.789     -10524.789      274.4549       274.4549       28038.365      28038.365     -462.72011     -462.72011    
     74000  -10455.664     -10455.664     -10526.924     -10526.924      275.78317      275.78317      27981.269      27981.269      2426.7323      2426.7323    
Loop time of 70.0464 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.233 ns/day, 19.457 hours/ns, 14.276 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    | 69.958     | 69.958     | 69.958     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01935    | 0.01935    | 0.01935    |   0.0 |  0.03
Output  | 0.0001061  | 0.0001061  | 0.0001061  |   0.0 |  0.00
Modify  | 0.062162   | 0.062162   | 0.062162   |   0.0 |  0.09
Other   |            | 0.006337   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325242 ave      325242 max      325242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325242
Ave neighs/atom = 162.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.988287593538, Press = -1.82024291899314
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10455.664     -10455.664     -10526.924     -10526.924      275.78317      275.78317      27981.269      27981.269      2426.7323      2426.7323    
     75000  -10454.796     -10454.796     -10525.216     -10525.216      272.53434      272.53434      28067.823      28067.823     -2158.381      -2158.381     
Loop time of 69.9012 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.236 ns/day, 19.417 hours/ns, 14.306 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    | 69.814     | 69.814     | 69.814     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019168   | 0.019168   | 0.019168   |   0.0 |  0.03
Output  | 2.9415e-05 | 2.9415e-05 | 2.9415e-05 |   0.0 |  0.00
Modify  | 0.06186    | 0.06186    | 0.06186    |   0.0 |  0.09
Other   |            | 0.006306   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       326058 ave      326058 max      326058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 326058
Ave neighs/atom = 163.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.025552618221, Press = -0.479163345658967
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10454.796     -10454.796     -10525.216     -10525.216      272.53434      272.53434      28067.823      28067.823     -2158.381      -2158.381     
     76000  -10453.001     -10453.001     -10524.417     -10524.417      276.38889      276.38889      28004.641      28004.641      1386.2777      1386.2777    
Loop time of 69.9964 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.443 hours/ns, 14.286 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    | 69.908     | 69.908     | 69.908     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019468   | 0.019468   | 0.019468   |   0.0 |  0.03
Output  | 5.0696e-05 | 5.0696e-05 | 5.0696e-05 |   0.0 |  0.00
Modify  | 0.062259   | 0.062259   | 0.062259   |   0.0 |  0.09
Other   |            | 0.006253   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324688 ave      324688 max      324688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324688
Ave neighs/atom = 162.344
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.030372266962, Press = -0.800136404758175
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10453.001     -10453.001     -10524.417     -10524.417      276.38889      276.38889      28004.641      28004.641      1386.2777      1386.2777    
     77000  -10455.98      -10455.98      -10525.054     -10525.054      267.32381      267.32381      28051.351      28051.351     -1314.8484     -1314.8484    
Loop time of 69.7562 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.239 ns/day, 19.377 hours/ns, 14.336 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    | 69.669     | 69.669     | 69.669     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019312   | 0.019312   | 0.019312   |   0.0 |  0.03
Output  | 3.0738e-05 | 3.0738e-05 | 3.0738e-05 |   0.0 |  0.00
Modify  | 0.061972   | 0.061972   | 0.061972   |   0.0 |  0.09
Other   |            | 0.006213   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325268 ave      325268 max      325268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325268
Ave neighs/atom = 162.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 = 273.068584551915, Press = -1.15383135415199
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10455.98      -10455.98      -10525.054     -10525.054      267.32381      267.32381      28051.351      28051.351     -1314.8484     -1314.8484    
     78000  -10452.502     -10452.502     -10524.537     -10524.537      278.78314      278.78314      28005.442      28005.442      1382.0463      1382.0463    
Loop time of 70.1157 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.232 ns/day, 19.477 hours/ns, 14.262 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    | 70.028     | 70.028     | 70.028     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019506   | 0.019506   | 0.019506   |   0.0 |  0.03
Output  | 3.707e-05  | 3.707e-05  | 3.707e-05  |   0.0 |  0.00
Modify  | 0.062365   | 0.062365   | 0.062365   |   0.0 |  0.09
Other   |            | 0.006293   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       324974 ave      324974 max      324974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 324974
Ave neighs/atom = 162.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.084952512327, Press = -0.234351071792152
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10452.502     -10452.502     -10524.537     -10524.537      278.78314      278.78314      28005.442      28005.442      1382.0463      1382.0463    
     79000  -10455.426     -10455.426     -10527.3       -10527.3        278.16058      278.16058      28045.303      28045.303     -1015.7775     -1015.7775    
Loop time of 69.9657 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.235 ns/day, 19.435 hours/ns, 14.293 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    | 69.878     | 69.878     | 69.878     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019494   | 0.019494   | 0.019494   |   0.0 |  0.03
Output  | 3.4055e-05 | 3.4055e-05 | 3.4055e-05 |   0.0 |  0.00
Modify  | 0.062366   | 0.062366   | 0.062366   |   0.0 |  0.09
Other   |            | 0.00627    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325288 ave      325288 max      325288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 325288
Ave neighs/atom = 162.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 = 273.120406035335, Press = -1.73042288159893
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10455.426     -10455.426     -10527.3       -10527.3        278.16058      278.16058      28045.303      28045.303     -1015.7775     -1015.7775    
     80000  -10453.14      -10453.14      -10525.215     -10525.215      278.93664      278.93664      28033.752      28033.752     -169.78141     -169.78141    
Loop time of 70.0046 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.234 ns/day, 19.446 hours/ns, 14.285 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    | 69.917     | 69.917     | 69.917     |   0.0 | 99.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019266   | 0.019266   | 0.019266   |   0.0 |  0.03
Output  | 3.7681e-05 | 3.7681e-05 | 3.7681e-05 |   0.0 |  0.00
Modify  | 0.061815   | 0.061815   | 0.061815   |   0.0 |  0.09
Other   |            | 0.006278   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 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:       325370 ave      325370 max      325370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0