# 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 2.863645806908607*${_u_distance}
variable latticeconst_converted equal 2.863645806908607*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86364580690861
Lattice spacing in x,y,z = 2.8636458 2.8636458 2.8636458
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.636458 28.636458 28.636458)
  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 (28.636458 28.636458 28.636458)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdFe__MO_924736622203_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.2338195995 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_924736622203_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8499.5042     -8499.5042     -8580.4194     -8580.4194      313.15         313.15         23483.234      23483.234      3680.3303      3680.3303    
      1000  -8414.4401     -8414.4401     -8492.3487     -8492.3487      301.51456      301.51456      23712.064      23712.064      2573.8727      2573.8727    
Loop time of 60.2806 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.433 ns/day, 16.745 hours/ns, 16.589 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    | 60.2       | 60.2       | 60.2       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015084   | 0.015084   | 0.015084   |   0.0 |  0.03
Output  | 0.00014361 | 0.00014361 | 0.00014361 |   0.0 |  0.00
Modify  | 0.059977   | 0.059977   | 0.059977   |   0.0 |  0.10
Other   |            | 0.005711   |            |       |  0.01

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

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8414.4401     -8414.4401     -8492.3487     -8492.3487      301.51456      301.51456      23712.064      23712.064      2573.8727      2573.8727    
      2000  -8415.1636     -8415.1636     -8495.3632     -8495.3632      310.38087      310.38087      23749.583      23749.583     -439.76071     -439.76071    
Loop time of 63.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.370 ns/day, 17.523 hours/ns, 15.852 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    | 63.004     | 63.004     | 63.004     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.02
Output  | 3.7822e-05 | 3.7822e-05 | 3.7822e-05 |   0.0 |  0.00
Modify  | 0.05938    | 0.05938    | 0.05938    |   0.0 |  0.09
Other   |            | 0.005536   |            |       |  0.01

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

Total # of neighbors = 212230
Ave neighs/atom = 106.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8415.1636     -8415.1636     -8495.3632     -8495.3632      310.38087      310.38087      23749.583      23749.583     -439.76071     -439.76071    
      3000  -8416.3763     -8416.3763     -8491.3621     -8491.3621      290.2027       290.2027       23757.11       23757.11      -577.00894     -577.00894    
Loop time of 63.2942 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.582 hours/ns, 15.799 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.214     | 63.214     | 63.214     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014829   | 0.014829   | 0.014829   |   0.0 |  0.02
Output  | 3.6459e-05 | 3.6459e-05 | 3.6459e-05 |   0.0 |  0.00
Modify  | 0.059365   | 0.059365   | 0.059365   |   0.0 |  0.09
Other   |            | 0.005493   |            |       |  0.01

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

Total # of neighbors = 212492
Ave neighs/atom = 106.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8416.3763     -8416.3763     -8491.3621     -8491.3621      290.2027       290.2027       23757.11       23757.11      -577.00894     -577.00894    
      4000  -8414.0653     -8414.0653     -8496.858      -8496.858       320.41625      320.41625      23747.541      23747.541     -487.9201      -487.9201     
Loop time of 63.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.581 hours/ns, 15.800 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    | 63.212     | 63.212     | 63.212     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014876   | 0.014876   | 0.014876   |   0.0 |  0.02
Output  | 3.7571e-05 | 3.7571e-05 | 3.7571e-05 |   0.0 |  0.00
Modify  | 0.059398   | 0.059398   | 0.059398   |   0.0 |  0.09
Other   |            | 0.005472   |            |       |  0.01

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

Total # of neighbors = 211796
Ave neighs/atom = 105.898
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8414.0653     -8414.0653     -8496.858      -8496.858       320.41625      320.41625      23747.541      23747.541     -487.9201      -487.9201     
      5000  -8416.4043     -8416.4043     -8498.3687     -8498.3687      317.211        317.211        23724.253      23724.253      987.68409      987.68409    
Loop time of 63.3354 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.593 hours/ns, 15.789 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    | 63.255     | 63.255     | 63.255     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014856   | 0.014856   | 0.014856   |   0.0 |  0.02
Output  | 3.0307e-05 | 3.0307e-05 | 3.0307e-05 |   0.0 |  0.00
Modify  | 0.059575   | 0.059575   | 0.059575   |   0.0 |  0.09
Other   |            | 0.005447   |            |       |  0.01

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

Total # of neighbors = 212294
Ave neighs/atom = 106.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.941991319836, Press = 1154.13856759211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8416.4043     -8416.4043     -8498.3687     -8498.3687      317.211        317.211        23724.253      23724.253      987.68409      987.68409    
      6000  -8414.1957     -8414.1957     -8498.1848     -8498.1848      325.04653      325.04653      23689.025      23689.025      3654.9778      3654.9778    
Loop time of 63.5533 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.359 ns/day, 17.654 hours/ns, 15.735 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    | 63.471     | 63.471     | 63.471     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.02
Output  | 3.2321e-05 | 3.2321e-05 | 3.2321e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.10
Other   |            | 0.005502   |            |       |  0.01

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

Total # of neighbors = 213056
Ave neighs/atom = 106.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.986969381345, Press = 89.2126637026045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8414.1957     -8414.1957     -8498.1848     -8498.1848      325.04653      325.04653      23689.025      23689.025      3654.9778      3654.9778    
      7000  -8418.923      -8418.923      -8499.8807     -8499.8807      313.31475      313.31475      23714.961      23714.961      1315.1441      1315.1441    
Loop time of 63.5205 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.360 ns/day, 17.645 hours/ns, 15.743 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    | 63.438     | 63.438     | 63.438     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.02
Output  | 3.2341e-05 | 3.2341e-05 | 3.2341e-05 |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.10
Other   |            | 0.005495   |            |       |  0.01

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

Total # of neighbors = 213838
Ave neighs/atom = 106.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.540140920618, Press = 13.2979927697772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8418.923      -8418.923      -8499.8807     -8499.8807      313.31475      313.31475      23714.961      23714.961      1315.1441      1315.1441    
      8000  -8414.7026     -8414.7026     -8495.8413     -8495.8413      314.01497      314.01497      23741.164      23741.164      97.688893      97.688893    
Loop time of 63.3617 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.600 hours/ns, 15.782 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    | 63.28      | 63.28      | 63.28      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014854   | 0.014854   | 0.014854   |   0.0 |  0.02
Output  | 3.0738e-05 | 3.0738e-05 | 3.0738e-05 |   0.0 |  0.00
Modify  | 0.061679   | 0.061679   | 0.061679   |   0.0 |  0.10
Other   |            | 0.005518   |            |       |  0.01

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

Total # of neighbors = 213186
Ave neighs/atom = 106.593
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.26618496633, Press = 9.31098888945848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8414.7026     -8414.7026     -8495.8413     -8495.8413      314.01497      314.01497      23741.164      23741.164      97.688893      97.688893    
      9000  -8415.8969     -8415.8969     -8494.6539     -8494.6539      304.79758      304.79758      23750.184      23750.184     -378.28653     -378.28653    
Loop time of 63.2079 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.558 hours/ns, 15.821 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.126     | 63.126     | 63.126     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014968   | 0.014968   | 0.014968   |   0.0 |  0.02
Output  | 3.138e-05  | 3.138e-05  | 3.138e-05  |   0.0 |  0.00
Modify  | 0.061832   | 0.061832   | 0.061832   |   0.0 |  0.10
Other   |            | 0.005486   |            |       |  0.01

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

Total # of neighbors = 212340
Ave neighs/atom = 106.17
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.615484354716, Press = 8.53021278127896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8415.8969     -8415.8969     -8494.6539     -8494.6539      304.79758      304.79758      23750.184      23750.184     -378.28653     -378.28653    
     10000  -8412.6615     -8412.6615     -8494.4002     -8494.4002      316.33711      316.33711      23760.874      23760.874     -1059.5327     -1059.5327    
Loop time of 63.2868 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.580 hours/ns, 15.801 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.205     | 63.205     | 63.205     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.02
Output  | 3.5226e-05 | 3.5226e-05 | 3.5226e-05 |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.10
Other   |            | 0.005484   |            |       |  0.01

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

Total # of neighbors = 211908
Ave neighs/atom = 105.954
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.550531416772, Press = 8.08480249825333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8412.6615     -8412.6615     -8494.4002     -8494.4002      316.33711      316.33711      23760.874      23760.874     -1059.5327     -1059.5327    
     11000  -8416.5703     -8416.5703     -8496.8715     -8496.8715      310.77408      310.77408      23760.429      23760.429     -1408.5126     -1408.5126    
Loop time of 63.1698 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.547 hours/ns, 15.830 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    | 63.088     | 63.088     | 63.088     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014835   | 0.014835   | 0.014835   |   0.0 |  0.02
Output  | 3.162e-05  | 3.162e-05  | 3.162e-05  |   0.0 |  0.00
Modify  | 0.061767   | 0.061767   | 0.061767   |   0.0 |  0.10
Other   |            | 0.005496   |            |       |  0.01

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

Total # of neighbors = 212132
Ave neighs/atom = 106.066
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.064607835063, Press = 6.08389237004159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8416.5703     -8416.5703     -8496.8715     -8496.8715      310.77408      310.77408      23760.429      23760.429     -1408.5126     -1408.5126    
     12000  -8410.8685     -8410.8685     -8494.3108     -8494.3108      322.93041      322.93041      23773.011      23773.011     -1617.5814     -1617.5814    
Loop time of 63.3969 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.610 hours/ns, 15.774 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    | 63.315     | 63.315     | 63.315     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014872   | 0.014872   | 0.014872   |   0.0 |  0.02
Output  | 4.7469e-05 | 4.7469e-05 | 4.7469e-05 |   0.0 |  0.00
Modify  | 0.061744   | 0.061744   | 0.061744   |   0.0 |  0.10
Other   |            | 0.005515   |            |       |  0.01

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

Total # of neighbors = 212398
Ave neighs/atom = 106.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.397227514449, Press = 10.7085286338757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8410.8685     -8410.8685     -8494.3108     -8494.3108      322.93041      322.93041      23773.011      23773.011     -1617.5814     -1617.5814    
     13000  -8416.1751     -8416.1751     -8495.9867     -8495.9867      308.87899      308.87899      23752.627      23752.627     -825.8187      -825.8187     
Loop time of 63.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.548 hours/ns, 15.829 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.092     | 63.092     | 63.092     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.02
Output  | 3.1509e-05 | 3.1509e-05 | 3.1509e-05 |   0.0 |  0.00
Modify  | 0.061806   | 0.061806   | 0.061806   |   0.0 |  0.10
Other   |            | 0.005597   |            |       |  0.01

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

Total # of neighbors = 211890
Ave neighs/atom = 105.945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.747033462218, Press = 13.1435640481227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8416.1751     -8416.1751     -8495.9867     -8495.9867      308.87899      308.87899      23752.627      23752.627     -825.8187      -825.8187     
     14000  -8410.9594     -8410.9594     -8495.0033     -8495.0033      325.25844      325.25844      23730.001      23730.001      1125.9303      1125.9303    
Loop time of 63.2656 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.574 hours/ns, 15.806 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.183     | 63.183     | 63.183     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.02
Output  | 3.2501e-05 | 3.2501e-05 | 3.2501e-05 |   0.0 |  0.00
Modify  | 0.061858   | 0.061858   | 0.061858   |   0.0 |  0.10
Other   |            | 0.005602   |            |       |  0.01

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

Total # of neighbors = 211980
Ave neighs/atom = 105.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.050745832519, Press = 14.9699355478756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8410.9594     -8410.9594     -8495.0033     -8495.0033      325.25844      325.25844      23730.001      23730.001      1125.9303      1125.9303    
     15000  -8414.6089     -8414.6089     -8495.9539     -8495.9539      314.81341      314.81341      23702.008      23702.008      2868.004       2868.004     
Loop time of 63.4409 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.622 hours/ns, 15.763 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    | 63.359     | 63.359     | 63.359     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014848   | 0.014848   | 0.014848   |   0.0 |  0.02
Output  | 3.173e-05  | 3.173e-05  | 3.173e-05  |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.10
Other   |            | 0.005509   |            |       |  0.01

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

Total # of neighbors = 212508
Ave neighs/atom = 106.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.151645449078, Press = 9.64078420325272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8414.6089     -8414.6089     -8495.9539     -8495.9539      314.81341      314.81341      23702.008      23702.008      2868.004       2868.004     
     16000  -8414.9521     -8414.9521     -8495.2752     -8495.2752      310.85869      310.85869      23721.153      23721.153      1661.2103      1661.2103    
Loop time of 63.4796 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.361 ns/day, 17.633 hours/ns, 15.753 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    | 63.397     | 63.397     | 63.397     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014849   | 0.014849   | 0.014849   |   0.0 |  0.02
Output  | 3.2e-05    | 3.2e-05    | 3.2e-05    |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.10
Other   |            | 0.00549    |            |       |  0.01

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

Total # of neighbors = 213020
Ave neighs/atom = 106.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.205573119136, Press = 3.7642585741016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8414.9521     -8414.9521     -8495.2752     -8495.2752      310.85869      310.85869      23721.153      23721.153      1661.2103      1661.2103    
     17000  -8416.647      -8416.647      -8496.9204     -8496.9204      310.66629      310.66629      23728.684      23728.684      892.17782      892.17782    
Loop time of 63.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 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    | 63.288     | 63.288     | 63.288     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014908   | 0.014908   | 0.014908   |   0.0 |  0.02
Output  | 3.206e-05  | 3.206e-05  | 3.206e-05  |   0.0 |  0.00
Modify  | 0.061684   | 0.061684   | 0.061684   |   0.0 |  0.10
Other   |            | 0.005501   |            |       |  0.01

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

Total # of neighbors = 212680
Ave neighs/atom = 106.34
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.192801167573, Press = 2.61450191513825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8416.647      -8416.647      -8496.9204     -8496.9204      310.66629      310.66629      23728.684      23728.684      892.17782      892.17782    
     18000  -8413.9968     -8413.9968     -8495.3334     -8495.3334      314.78093      314.78093      23739.709      23739.709      364.64633      364.64633    
Loop time of 63.3781 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.605 hours/ns, 15.778 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    | 63.296     | 63.296     | 63.296     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.02
Output  | 3.1109e-05 | 3.1109e-05 | 3.1109e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.10
Other   |            | 0.005505   |            |       |  0.01

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

Total # of neighbors = 213034
Ave neighs/atom = 106.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.432804836511, Press = 2.19715585044087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8413.9968     -8413.9968     -8495.3334     -8495.3334      314.78093      314.78093      23739.709      23739.709      364.64633      364.64633    
     19000  -8415.8127     -8415.8127     -8494.6384     -8494.6384      305.06366      305.06366      23744.649      23744.649      15.676849      15.676849    
Loop time of 63.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.614 hours/ns, 15.771 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    | 63.327     | 63.327     | 63.327     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014936   | 0.014936   | 0.014936   |   0.0 |  0.02
Output  | 3.166e-05  | 3.166e-05  | 3.166e-05  |   0.0 |  0.00
Modify  | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.10
Other   |            | 0.005504   |            |       |  0.01

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

Total # of neighbors = 212506
Ave neighs/atom = 106.253
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.574332720404, Press = -1.06887799073413
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8415.8127     -8415.8127     -8494.6384     -8494.6384      305.06366      305.06366      23744.649      23744.649      15.676849      15.676849    
     20000  -8415.7791     -8415.7791     -8497.2686     -8497.2686      315.37297      315.37297      23775.278      23775.278     -2657.0307     -2657.0307    
Loop time of 63.3861 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.607 hours/ns, 15.776 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    | 63.304     | 63.304     | 63.304     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014944   | 0.014944   | 0.014944   |   0.0 |  0.02
Output  | 3.2482e-05 | 3.2482e-05 | 3.2482e-05 |   0.0 |  0.00
Modify  | 0.061697   | 0.061697   | 0.061697   |   0.0 |  0.10
Other   |            | 0.005503   |            |       |  0.01

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

Total # of neighbors = 212296
Ave neighs/atom = 106.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.536966568444, Press = -2.65347906388109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8415.7791     -8415.7791     -8497.2686     -8497.2686      315.37297      315.37297      23775.278      23775.278     -2657.0307     -2657.0307    
     21000  -8414.6556     -8414.6556     -8495.0524     -8495.0524      311.14388      311.14388      23785.068      23785.068     -2925.3734     -2925.3734    
Loop time of 63.4245 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.618 hours/ns, 15.767 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    | 63.342     | 63.342     | 63.342     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.02
Output  | 3.1229e-05 | 3.1229e-05 | 3.1229e-05 |   0.0 |  0.00
Modify  | 0.061662   | 0.061662   | 0.061662   |   0.0 |  0.10
Other   |            | 0.005492   |            |       |  0.01

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

Total # of neighbors = 212174
Ave neighs/atom = 106.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.532101429046, Press = 1.55353220212827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8414.6556     -8414.6556     -8495.0524     -8495.0524      311.14388      311.14388      23785.068      23785.068     -2925.3734     -2925.3734    
     22000  -8414.573      -8414.573      -8494.6992     -8494.6992      310.09676      310.09676      23769.62       23769.62      -1723.3893     -1723.3893    
Loop time of 63.1768 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.368 ns/day, 17.549 hours/ns, 15.829 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    | 63.095     | 63.095     | 63.095     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.02
Output  | 3.1539e-05 | 3.1539e-05 | 3.1539e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.10
Other   |            | 0.005477   |            |       |  0.01

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

Total # of neighbors = 211648
Ave neighs/atom = 105.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 = 313.536868487828, Press = 4.24238687447685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8414.573      -8414.573      -8494.6992     -8494.6992      310.09676      310.09676      23769.62       23769.62      -1723.3893     -1723.3893    
     23000  -8412.8638     -8412.8638     -8496.5337     -8496.5337      323.81121      323.81121      23760.592      23760.592     -1305.6188     -1305.6188    
Loop time of 63.2734 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.576 hours/ns, 15.804 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    | 63.191     | 63.191     | 63.191     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.02
Output  | 3.0718e-05 | 3.0718e-05 | 3.0718e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.10
Other   |            | 0.005493   |            |       |  0.01

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

Total # of neighbors = 212206
Ave neighs/atom = 106.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.67259316337, Press = 4.8589992531876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8412.8638     -8412.8638     -8496.5337     -8496.5337      323.81121      323.81121      23760.592      23760.592     -1305.6188     -1305.6188    
     24000  -8417.3724     -8417.3724     -8496.7219     -8496.7219      307.09053      307.09053      23740.694      23740.694     -30.73228      -30.73228     
Loop time of 63.3269 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.591 hours/ns, 15.791 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    | 63.245     | 63.245     | 63.245     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014912   | 0.014912   | 0.014912   |   0.0 |  0.02
Output  | 3.188e-05  | 3.188e-05  | 3.188e-05  |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.10
Other   |            | 0.005487   |            |       |  0.01

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

Total # of neighbors = 212366
Ave neighs/atom = 106.183
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.640745217581, Press = 5.36120869947719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8417.3724     -8417.3724     -8496.7219     -8496.7219      307.09053      307.09053      23740.694      23740.694     -30.73228      -30.73228     
     25000  -8414.8525     -8414.8525     -8496.4291     -8496.4291      315.70985      315.70985      23707.309      23707.309      2559.0813      2559.0813    
Loop time of 63.3851 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.607 hours/ns, 15.777 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    | 63.303     | 63.303     | 63.303     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014923   | 0.014923   | 0.014923   |   0.0 |  0.02
Output  | 2.8594e-05 | 2.8594e-05 | 2.8594e-05 |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.10
Other   |            | 0.005483   |            |       |  0.01

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

Total # of neighbors = 212652
Ave neighs/atom = 106.326
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.560430185936, Press = 9.02562622357367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8414.8525     -8414.8525     -8496.4291     -8496.4291      315.70985      315.70985      23707.309      23707.309      2559.0813      2559.0813    
     26000  -8417.7844     -8417.7844     -8496.952      -8496.952       306.38683      306.38683      23697.57       23697.57       3014.4703      3014.4703    
Loop time of 63.3726 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 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    | 63.29      | 63.29      | 63.29      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014869   | 0.014869   | 0.014869   |   0.0 |  0.02
Output  | 3.0127e-05 | 3.0127e-05 | 3.0127e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.10
Other   |            | 0.005487   |            |       |  0.01

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

Total # of neighbors = 212824
Ave neighs/atom = 106.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.427780972168, Press = 4.4992196555786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8417.7844     -8417.7844     -8496.952      -8496.952       306.38683      306.38683      23697.57       23697.57       3014.4703      3014.4703    
     27000  -8414.2379     -8414.2379     -8495.6236     -8495.6236      314.97087      314.97087      23715.987      23715.987      2044.9237      2044.9237    
Loop time of 63.4673 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.361 ns/day, 17.630 hours/ns, 15.756 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    | 63.385     | 63.385     | 63.385     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.02
Output  | 3.1119e-05 | 3.1119e-05 | 3.1119e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.10
Other   |            | 0.005504   |            |       |  0.01

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

Total # of neighbors = 213432
Ave neighs/atom = 106.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.422385161869, Press = 2.58389109418227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8414.2379     -8414.2379     -8495.6236     -8495.6236      314.97087      314.97087      23715.987      23715.987      2044.9237      2044.9237    
     28000  -8421.7601     -8421.7601     -8499.3401     -8499.3401      300.24263      300.24263      23712.768      23712.768      1467.5539      1467.5539    
Loop time of 63.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.608 hours/ns, 15.776 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    | 63.306     | 63.306     | 63.306     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014907   | 0.014907   | 0.014907   |   0.0 |  0.02
Output  | 3.1329e-05 | 3.1329e-05 | 3.1329e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.10
Other   |            | 0.005488   |            |       |  0.01

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

Total # of neighbors = 213024
Ave neighs/atom = 106.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.334074946775, Press = 1.10903632016653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8421.7601     -8421.7601     -8499.3401     -8499.3401      300.24263      300.24263      23712.768      23712.768      1467.5539      1467.5539    
     29000  -8415.0671     -8415.0671     -8495.6931     -8495.6931      312.03098      312.03098      23738.26       23738.26       354.46412      354.46412    
Loop time of 63.4791 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.361 ns/day, 17.633 hours/ns, 15.753 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    | 63.397     | 63.397     | 63.397     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.02
Output  | 3.177e-05  | 3.177e-05  | 3.177e-05  |   0.0 |  0.00
Modify  | 0.061626   | 0.061626   | 0.061626   |   0.0 |  0.10
Other   |            | 0.005488   |            |       |  0.01

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

Total # of neighbors = 213486
Ave neighs/atom = 106.743
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.227647245617, Press = 0.467339457505198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8415.0671     -8415.0671     -8495.6931     -8495.6931      312.03098      312.03098      23738.26       23738.26       354.46412      354.46412    
     30000  -8417.3337     -8417.3337     -8495.5348     -8495.5348      302.64633      302.64633      23762.734      23762.734     -1424.4399     -1424.4399    
Loop time of 63.3807 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.606 hours/ns, 15.778 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    | 63.298     | 63.298     | 63.298     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.02
Output  | 3.0718e-05 | 3.0718e-05 | 3.0718e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.10
Other   |            | 0.005507   |            |       |  0.01

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

Total # of neighbors = 212372
Ave neighs/atom = 106.186
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.198952777239, Press = -1.98520713107215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8417.3337     -8417.3337     -8495.5348     -8495.5348      302.64633      302.64633      23762.734      23762.734     -1424.4399     -1424.4399    
     31000  -8415.9863     -8415.9863     -8496.1213     -8496.1213      310.13057      310.13057      23800.309      23800.309     -3974.8537     -3974.8537    
Loop time of 63.3595 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.600 hours/ns, 15.783 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    | 63.277     | 63.277     | 63.277     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014857   | 0.014857   | 0.014857   |   0.0 |  0.02
Output  | 3.0878e-05 | 3.0878e-05 | 3.0878e-05 |   0.0 |  0.00
Modify  | 0.061763   | 0.061763   | 0.061763   |   0.0 |  0.10
Other   |            | 0.005482   |            |       |  0.01

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

Total # of neighbors = 212330
Ave neighs/atom = 106.165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.061254504517, Press = 0.385703133118693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8415.9863     -8415.9863     -8496.1213     -8496.1213      310.13057      310.13057      23800.309      23800.309     -3974.8537     -3974.8537    
     32000  -8416.1402     -8416.1402     -8497.8514     -8497.8514      316.2308       316.2308       23771.355      23771.355     -2320.5579     -2320.5579    
Loop time of 63.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.599 hours/ns, 15.784 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    | 63.273     | 63.273     | 63.273     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.02
Output  | 3.691e-05  | 3.691e-05  | 3.691e-05  |   0.0 |  0.00
Modify  | 0.061714   | 0.061714   | 0.061714   |   0.0 |  0.10
Other   |            | 0.005355   |            |       |  0.01

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

Total # of neighbors = 211910
Ave neighs/atom = 105.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.036701295287, Press = 2.61267279503539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8416.1402     -8416.1402     -8497.8514     -8497.8514      316.2308       316.2308       23771.355      23771.355     -2320.5579     -2320.5579    
     33000  -8409.3776     -8409.3776     -8494.2776     -8494.2776      328.57169      328.57169      23773.793      23773.793     -1766.8641     -1766.8641    
Loop time of 63.4306 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.620 hours/ns, 15.765 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    | 63.349     | 63.349     | 63.349     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01479    | 0.01479    | 0.01479    |   0.0 |  0.02
Output  | 3.1099e-05 | 3.1099e-05 | 3.1099e-05 |   0.0 |  0.00
Modify  | 0.061642   | 0.061642   | 0.061642   |   0.0 |  0.10
Other   |            | 0.005328   |            |       |  0.01

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

Total # of neighbors = 212286
Ave neighs/atom = 106.143
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.050268888526, Press = 3.37323490522746
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8409.3776     -8409.3776     -8494.2776     -8494.2776      328.57169      328.57169      23773.793      23773.793     -1766.8641     -1766.8641    
     34000  -8415.7905     -8415.7905     -8495.0039     -8495.0039      306.56407      306.56407      23742.418      23742.418      62.343097      62.343097    
Loop time of 63.3284 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.591 hours/ns, 15.791 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    | 63.247     | 63.247     | 63.247     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014683   | 0.014683   | 0.014683   |   0.0 |  0.02
Output  | 3.0988e-05 | 3.0988e-05 | 3.0988e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.005341   |            |       |  0.01

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

Total # of neighbors = 211854
Ave neighs/atom = 105.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.124350577116, Press = 3.53180729926193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8415.7905     -8415.7905     -8495.0039     -8495.0039      306.56407      306.56407      23742.418      23742.418      62.343097      62.343097    
     35000  -8410.4464     -8410.4464     -8492.6553     -8492.6553      318.15704      318.15704      23736.917      23736.917      1047.8027      1047.8027    
Loop time of 63.451 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.625 hours/ns, 15.760 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    | 63.369     | 63.369     | 63.369     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014734   | 0.014734   | 0.014734   |   0.0 |  0.02
Output  | 3.158e-05  | 3.158e-05  | 3.158e-05  |   0.0 |  0.00
Modify  | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.10
Other   |            | 0.005267   |            |       |  0.01

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

Total # of neighbors = 212626
Ave neighs/atom = 106.313
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.194342768676, Press = 4.11827157286369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8410.4464     -8410.4464     -8492.6553     -8492.6553      318.15704      318.15704      23736.917      23736.917      1047.8027      1047.8027    
     36000  -8416.8272     -8416.8272     -8495.5733     -8495.5733      304.75554      304.75554      23674.824      23674.824      5020.0428      5020.0428    
Loop time of 63.3815 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.606 hours/ns, 15.777 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    | 63.3       | 63.3       | 63.3       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014874   | 0.014874   | 0.014874   |   0.0 |  0.02
Output  | 3.201e-05  | 3.201e-05  | 3.201e-05  |   0.0 |  0.00
Modify  | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.10
Other   |            | 0.005219   |            |       |  0.01

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

Total # of neighbors = 212332
Ave neighs/atom = 106.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.237866493654, Press = 3.83560749314263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8416.8272     -8416.8272     -8495.5733     -8495.5733      304.75554      304.75554      23674.824      23674.824      5020.0428      5020.0428    
     37000  -8415.7667     -8415.7667     -8496.1055     -8496.1055      310.91949      310.91949      23699.464      23699.464      3117.8345      3117.8345    
Loop time of 63.3056 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.585 hours/ns, 15.796 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    | 63.224     | 63.224     | 63.224     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014771   | 0.014771   | 0.014771   |   0.0 |  0.02
Output  | 3.1109e-05 | 3.1109e-05 | 3.1109e-05 |   0.0 |  0.00
Modify  | 0.061516   | 0.061516   | 0.061516   |   0.0 |  0.10
Other   |            | 0.005216   |            |       |  0.01

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

Total # of neighbors = 213498
Ave neighs/atom = 106.749
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.179707658974, Press = 1.9369019613384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8415.7667     -8415.7667     -8496.1055     -8496.1055      310.91949      310.91949      23699.464      23699.464      3117.8345      3117.8345    
     38000  -8415.8688     -8415.8688     -8497.7756     -8497.7756      316.98763      316.98763      23722.405      23722.405      1225.1856      1225.1856    
Loop time of 63.4097 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.614 hours/ns, 15.770 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    | 63.328     | 63.328     | 63.328     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014811   | 0.014811   | 0.014811   |   0.0 |  0.02
Output  | 3.2231e-05 | 3.2231e-05 | 3.2231e-05 |   0.0 |  0.00
Modify  | 0.061626   | 0.061626   | 0.061626   |   0.0 |  0.10
Other   |            | 0.005224   |            |       |  0.01

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

Total # of neighbors = 213352
Ave neighs/atom = 106.676
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.163733783241, Press = 0.564097973226379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8415.8688     -8415.8688     -8497.7756     -8497.7756      316.98763      316.98763      23722.405      23722.405      1225.1856      1225.1856    
     39000  -8411.5342     -8411.5342     -8494.5512     -8494.5512      321.28422      321.28422      23749.475      23749.475     -133.05154     -133.05154    
Loop time of 63.3405 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.595 hours/ns, 15.788 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    | 63.259     | 63.259     | 63.259     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014737   | 0.014737   | 0.014737   |   0.0 |  0.02
Output  | 3.4856e-05 | 3.4856e-05 | 3.4856e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.10
Other   |            | 0.005259   |            |       |  0.01

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

Total # of neighbors = 212996
Ave neighs/atom = 106.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.155612079172, Press = 0.486684892793456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8411.5342     -8411.5342     -8494.5512     -8494.5512      321.28422      321.28422      23749.475      23749.475     -133.05154     -133.05154    
     40000  -8415.0164     -8415.0164     -8495.633      -8495.633       311.99459      311.99459      23764.933      23764.933     -1321.5018     -1321.5018    
Loop time of 63.3828 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.606 hours/ns, 15.777 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    | 63.301     | 63.301     | 63.301     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014952   | 0.014952   | 0.014952   |   0.0 |  0.02
Output  | 3.197e-05  | 3.197e-05  | 3.197e-05  |   0.0 |  0.00
Modify  | 0.061588   | 0.061588   | 0.061588   |   0.0 |  0.10
Other   |            | 0.005231   |            |       |  0.01

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

Total # of neighbors = 212350
Ave neighs/atom = 106.175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.259797030727, Press = 0.579819179460134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8415.0164     -8415.0164     -8495.633      -8495.633       311.99459      311.99459      23764.933      23764.933     -1321.5018     -1321.5018    
     41000  -8412.9471     -8412.9471     -8493.869      -8493.869       313.17587      313.17587      23775.537      23775.537     -1992.603      -1992.603     
Loop time of 63.2018 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.556 hours/ns, 15.822 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.12      | 63.12      | 63.12      |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014733   | 0.014733   | 0.014733   |   0.0 |  0.02
Output  | 3.2381e-05 | 3.2381e-05 | 3.2381e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.10
Other   |            | 0.005279   |            |       |  0.01

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

Total # of neighbors = 212218
Ave neighs/atom = 106.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.25207711383, Press = 1.92736354270602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8412.9471     -8412.9471     -8493.869      -8493.869       313.17587      313.17587      23775.537      23775.537     -1992.603      -1992.603     
     42000  -8417.8543     -8417.8543     -8497.2538     -8497.2538      307.28445      307.28445      23767.87       23767.87      -2085.8531     -2085.8531    
Loop time of 63.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.586 hours/ns, 15.795 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    | 63.228     | 63.228     | 63.228     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014769   | 0.014769   | 0.014769   |   0.0 |  0.02
Output  | 3.6098e-05 | 3.6098e-05 | 3.6098e-05 |   0.0 |  0.00
Modify  | 0.061648   | 0.061648   | 0.061648   |   0.0 |  0.10
Other   |            | 0.005253   |            |       |  0.01

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

Total # of neighbors = 211824
Ave neighs/atom = 105.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.257703552578, Press = 3.06888436365432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8417.8543     -8417.8543     -8497.2538     -8497.2538      307.28445      307.28445      23767.87       23767.87      -2085.8531     -2085.8531    
     43000  -8412.8332     -8412.8332     -8496.7219     -8496.7219      324.65795      324.65795      23762.245      23762.245     -1347.1657     -1347.1657    
Loop time of 63.3085 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.586 hours/ns, 15.796 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    | 63.227     | 63.227     | 63.227     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014861   | 0.014861   | 0.014861   |   0.0 |  0.02
Output  | 3.1961e-05 | 3.1961e-05 | 3.1961e-05 |   0.0 |  0.00
Modify  | 0.061705   | 0.061705   | 0.061705   |   0.0 |  0.10
Other   |            | 0.00525    |            |       |  0.01

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

Total # of neighbors = 212230
Ave neighs/atom = 106.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.183141559002, Press = 3.65227315971026
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8412.8332     -8412.8332     -8496.7219     -8496.7219      324.65795      324.65795      23762.245      23762.245     -1347.1657     -1347.1657    
     44000  -8417.4581     -8417.4581     -8496.2201     -8496.2201      304.81725      304.81725      23730.281      23730.281      794.7426       794.7426     
Loop time of 63.3135 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.587 hours/ns, 15.794 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    | 63.232     | 63.232     | 63.232     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014757   | 0.014757   | 0.014757   |   0.0 |  0.02
Output  | 3.2491e-05 | 3.2491e-05 | 3.2491e-05 |   0.0 |  0.00
Modify  | 0.061611   | 0.061611   | 0.061611   |   0.0 |  0.10
Other   |            | 0.00526    |            |       |  0.01

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

Total # of neighbors = 212086
Ave neighs/atom = 106.043
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.157508865158, Press = 3.17240051709647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8417.4581     -8417.4581     -8496.2201     -8496.2201      304.81725      304.81725      23730.281      23730.281      794.7426       794.7426     
     45000  -8412.5098     -8412.5098     -8494.462      -8494.462       317.16336      317.16336      23733.83       23733.83       1056.6253      1056.6253    
Loop time of 63.5331 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.360 ns/day, 17.648 hours/ns, 15.740 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    | 63.452     | 63.452     | 63.452     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014738   | 0.014738   | 0.014738   |   0.0 |  0.02
Output  | 3.3293e-05 | 3.3293e-05 | 3.3293e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.10
Other   |            | 0.005214   |            |       |  0.01

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

Total # of neighbors = 212694
Ave neighs/atom = 106.347
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.161189732313, Press = 2.19295315761912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8412.5098     -8412.5098     -8494.462      -8494.462       317.16336      317.16336      23733.83       23733.83       1056.6253      1056.6253    
     46000  -8416.2322     -8416.2322     -8495.2047     -8495.2047      305.63149      305.63149      23731.775      23731.775      826.67212      826.67212    
Loop time of 63.3702 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 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    | 63.289     | 63.289     | 63.289     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014844   | 0.014844   | 0.014844   |   0.0 |  0.02
Output  | 3.2391e-05 | 3.2391e-05 | 3.2391e-05 |   0.0 |  0.00
Modify  | 0.061542   | 0.061542   | 0.061542   |   0.0 |  0.10
Other   |            | 0.005232   |            |       |  0.01

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

Total # of neighbors = 212338
Ave neighs/atom = 106.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.189742570799, Press = 1.41070022558371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8416.2322     -8416.2322     -8495.2047     -8495.2047      305.63149      305.63149      23731.775      23731.775      826.67212      826.67212    
     47000  -8414.3181     -8414.3181     -8495.341      -8495.341       313.5673       313.5673       23741.208      23741.208      316.38264      316.38264    
Loop time of 63.3392 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.364 ns/day, 17.594 hours/ns, 15.788 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    | 63.257     | 63.257     | 63.257     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014811   | 0.014811   | 0.014811   |   0.0 |  0.02
Output  | 3.9073e-05 | 3.9073e-05 | 3.9073e-05 |   0.0 |  0.00
Modify  | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.10
Other   |            | 0.005254   |            |       |  0.01

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

Total # of neighbors = 212516
Ave neighs/atom = 106.258
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.24073353825, Press = 1.22781744618437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8414.3181     -8414.3181     -8495.341      -8495.341       313.5673       313.5673       23741.208      23741.208      316.38264      316.38264    
     48000  -8412.447      -8412.447      -8495.7427     -8495.7427      322.36276      322.36276      23751.405      23751.405     -460.21971     -460.21971    
Loop time of 63.4352 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.621 hours/ns, 15.764 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    | 63.354     | 63.354     | 63.354     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014786   | 0.014786   | 0.014786   |   0.0 |  0.02
Output  | 3.2862e-05 | 3.2862e-05 | 3.2862e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.10
Other   |            | 0.005257   |            |       |  0.01

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

Total # of neighbors = 212578
Ave neighs/atom = 106.289
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.245364444365, Press = 1.39458488721753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8412.447      -8412.447      -8495.7427     -8495.7427      322.36276      322.36276      23751.405      23751.405     -460.21971     -460.21971    
     49000  -8415.3213     -8415.3213     -8495.3248     -8495.3248      309.62183      309.62183      23742.43       23742.43       65.561692      65.561692    
Loop time of 63.1156 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.369 ns/day, 17.532 hours/ns, 15.844 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.034     | 63.034     | 63.034     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014706   | 0.014706   | 0.014706   |   0.0 |  0.02
Output  | 3.2582e-05 | 3.2582e-05 | 3.2582e-05 |   0.0 |  0.00
Modify  | 0.061614   | 0.061614   | 0.061614   |   0.0 |  0.10
Other   |            | 0.005247   |            |       |  0.01

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

Total # of neighbors = 212130
Ave neighs/atom = 106.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.30809233858, Press = 1.4946398010754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8415.3213     -8415.3213     -8495.3248     -8495.3248      309.62183      309.62183      23742.43       23742.43       65.561692      65.561692    
     50000  -8412.0308     -8412.0308     -8494.4687     -8494.4687      319.04329      319.04329      23746.072      23746.072      161.27078      161.27078    
Loop time of 63.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.568 hours/ns, 15.812 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    | 63.163     | 63.163     | 63.163     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014783   | 0.014783   | 0.014783   |   0.0 |  0.02
Output  | 3.2992e-05 | 3.2992e-05 | 3.2992e-05 |   0.0 |  0.00
Modify  | 0.061571   | 0.061571   | 0.061571   |   0.0 |  0.10
Other   |            | 0.005229   |            |       |  0.01

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

Total # of neighbors = 212404
Ave neighs/atom = 106.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.329862823251, Press = 1.87440056705523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8412.0308     -8412.0308     -8494.4687     -8494.4687      319.04329      319.04329      23746.072      23746.072      161.27078      161.27078    
     51000  -8416.6847     -8416.6847     -8495.6246     -8495.6246      305.50524      305.50524      23719.979      23719.979      1664.7761      1664.7761    
Loop time of 63.2301 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.564 hours/ns, 15.815 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    | 63.148     | 63.148     | 63.148     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014745   | 0.014745   | 0.014745   |   0.0 |  0.02
Output  | 3.1108e-05 | 3.1108e-05 | 3.1108e-05 |   0.0 |  0.00
Modify  | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.10
Other   |            | 0.005225   |            |       |  0.01

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

Total # of neighbors = 212210
Ave neighs/atom = 106.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.343460953734, Press = 1.96387851615991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8416.6847     -8416.6847     -8495.6246     -8495.6246      305.50524      305.50524      23719.979      23719.979      1664.7761      1664.7761    
     52000  -8412.7267     -8412.7267     -8495.956      -8495.956       322.10595      322.10595      23716.309      23716.309      2031.6108      2031.6108    
Loop time of 63.2024 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.556 hours/ns, 15.822 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.121     | 63.121     | 63.121     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014757   | 0.014757   | 0.014757   |   0.0 |  0.02
Output  | 3.1629e-05 | 3.1629e-05 | 3.1629e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.10
Other   |            | 0.005249   |            |       |  0.01

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

Total # of neighbors = 212794
Ave neighs/atom = 106.397
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.407582465973, Press = 1.54601175095822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8412.7267     -8412.7267     -8495.956      -8495.956       322.10595      322.10595      23716.309      23716.309      2031.6108      2031.6108    
     53000  -8415.4033     -8415.4033     -8496.7735     -8496.7735      314.91086      314.91086      23699.207      23699.207      3049.8582      3049.8582    
Loop time of 63.2085 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.558 hours/ns, 15.821 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    | 63.127     | 63.127     | 63.127     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014816   | 0.014816   | 0.014816   |   0.0 |  0.02
Output  | 3.1199e-05 | 3.1199e-05 | 3.1199e-05 |   0.0 |  0.00
Modify  | 0.061562   | 0.061562   | 0.061562   |   0.0 |  0.10
Other   |            | 0.005242   |            |       |  0.01

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

Total # of neighbors = 212746
Ave neighs/atom = 106.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.401491787676, Press = 0.808218590301966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8415.4033     -8415.4033     -8496.7735     -8496.7735      314.91086      314.91086      23699.207      23699.207      3049.8582      3049.8582    
     54000  -8412.3268     -8412.3268     -8495.6294     -8495.6294      322.38939      322.38939      23729.405      23729.405      1171.9199      1171.9199    
Loop time of 63.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.361 ns/day, 17.635 hours/ns, 15.751 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    | 63.404     | 63.404     | 63.404     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014765   | 0.014765   | 0.014765   |   0.0 |  0.02
Output  | 3.1619e-05 | 3.1619e-05 | 3.1619e-05 |   0.0 |  0.00
Modify  | 0.061573   | 0.061573   | 0.061573   |   0.0 |  0.10
Other   |            | 0.00529    |            |       |  0.01

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

Total # of neighbors = 213250
Ave neighs/atom = 106.625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426413502458, Press = -0.31649720946185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8412.3268     -8412.3268     -8495.6294     -8495.6294      322.38939      322.38939      23729.405      23729.405      1171.9199      1171.9199    
     55000  -8415.2975     -8415.2975     -8496.1927     -8496.1927      313.07263      313.07263      23749.913      23749.913     -414.74214     -414.74214    
Loop time of 63.4212 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.362 ns/day, 17.617 hours/ns, 15.768 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    | 63.339     | 63.339     | 63.339     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014857   | 0.014857   | 0.014857   |   0.0 |  0.02
Output  | 3.1089e-05 | 3.1089e-05 | 3.1089e-05 |   0.0 |  0.00
Modify  | 0.061649   | 0.061649   | 0.061649   |   0.0 |  0.10
Other   |            | 0.005257   |            |       |  0.01

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

Total # of neighbors = 212678
Ave neighs/atom = 106.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.441214883035, Press = 0.131336618748587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8415.2975     -8415.2975     -8496.1927     -8496.1927      313.07263      313.07263      23749.913      23749.913     -414.74214     -414.74214    
     56000  -8414.1299     -8414.1299     -8494.6544     -8494.6544      311.63823      311.63823      23759.923      23759.923     -1093.6521     -1093.6521    
Loop time of 63.2325 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.565 hours/ns, 15.815 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    | 63.151     | 63.151     | 63.151     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014807   | 0.014807   | 0.014807   |   0.0 |  0.02
Output  | 3.1519e-05 | 3.1519e-05 | 3.1519e-05 |   0.0 |  0.00
Modify  | 0.061599   | 0.061599   | 0.061599   |   0.0 |  0.10
Other   |            | 0.005226   |            |       |  0.01

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

Total # of neighbors = 212606
Ave neighs/atom = 106.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.500079647233, Press = 0.7202751014629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8414.1299     -8414.1299     -8494.6544     -8494.6544      311.63823      311.63823      23759.923      23759.923     -1093.6521     -1093.6521    
     57000  -8413.3958     -8413.3958     -8493.8838     -8493.8838      311.497        311.497        23747.91       23747.91       25.375321      25.375321    
Loop time of 63.1872 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.552 hours/ns, 15.826 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    | 63.106     | 63.106     | 63.106     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014766   | 0.014766   | 0.014766   |   0.0 |  0.02
Output  | 3.183e-05  | 3.183e-05  | 3.183e-05  |   0.0 |  0.00
Modify  | 0.061656   | 0.061656   | 0.061656   |   0.0 |  0.10
Other   |            | 0.005234   |            |       |  0.01

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

Total # of neighbors = 211878
Ave neighs/atom = 105.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.514446336761, Press = 1.19070908106218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8413.3958     -8413.3958     -8493.8838     -8493.8838      311.497        311.497        23747.91       23747.91       25.375321      25.375321    
     58000  -8417.3222     -8417.3222     -8497.5263     -8497.5263      310.39812      310.39812      23738.614      23738.614      11.691628      11.691628    
Loop time of 63.3831 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.606 hours/ns, 15.777 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    | 63.301     | 63.301     | 63.301     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014753   | 0.014753   | 0.014753   |   0.0 |  0.02
Output  | 3.2491e-05 | 3.2491e-05 | 3.2491e-05 |   0.0 |  0.00
Modify  | 0.061626   | 0.061626   | 0.061626   |   0.0 |  0.10
Other   |            | 0.005228   |            |       |  0.01

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

Total # of neighbors = 212244
Ave neighs/atom = 106.122
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.50921317861, Press = 1.0690909668613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8417.3222     -8417.3222     -8497.5263     -8497.5263      310.39812      310.39812      23738.614      23738.614      11.691628      11.691628    
     59000  -8414.6102     -8414.6102     -8496.7624     -8496.7624      317.93777      317.93777      23735.969      23735.969      610.07077      610.07077    
Loop time of 63.2325 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.366 ns/day, 17.565 hours/ns, 15.815 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    | 63.151     | 63.151     | 63.151     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014846   | 0.014846   | 0.014846   |   0.0 |  0.02
Output  | 3.0538e-05 | 3.0538e-05 | 3.0538e-05 |   0.0 |  0.00
Modify  | 0.061591   | 0.061591   | 0.061591   |   0.0 |  0.10
Other   |            | 0.005251   |            |       |  0.01

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

Total # of neighbors = 212860
Ave neighs/atom = 106.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 = 313.46122670183, Press = 1.05089719068628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8414.6102     -8414.6102     -8496.7624     -8496.7624      317.93777      317.93777      23735.969      23735.969      610.07077      610.07077    
     60000  -8417.6516     -8417.6516     -8495.9598     -8495.9598      303.06084      303.06084      23732.365      23732.365      726.05168      726.05168    
Loop time of 63.3812 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.363 ns/day, 17.606 hours/ns, 15.778 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    | 63.3       | 63.3       | 63.3       |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014793   | 0.014793   | 0.014793   |   0.0 |  0.02
Output  | 3.0638e-05 | 3.0638e-05 | 3.0638e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.10
Other   |            | 0.005236   |            |       |  0.01

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

Total # of neighbors = 212894
Ave neighs/atom = 106.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426336550446, Press = 0.0264199555556652
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8417.6516     -8417.6516     -8495.9598     -8495.9598      303.06084      303.06084      23732.365      23732.365      726.05168      726.05168    
     61000  -8415.0277     -8415.0277     -8495.4161     -8495.4161      311.11142      311.11142      23761.353      23761.353     -1160.1829     -1160.1829    
Loop time of 63.2846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.365 ns/day, 17.579 hours/ns, 15.802 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    | 63.203     | 63.203     | 63.203     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014809   | 0.014809   | 0.014809   |   0.0 |  0.02
Output  | 3.2161e-05 | 3.2161e-05 | 3.2161e-05 |   0.0 |  0.00
Modify  | 0.061611   | 0.061611   | 0.061611   |   0.0 |  0.10
Other   |            | 0.005242   |            |       |  0.01

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

Total # of neighbors = 212542
Ave neighs/atom = 106.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363135509025, Press = -0.34510559606086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8415.0277     -8415.0277     -8495.4161     -8495.4161      311.11142      311.11142      23761.353      23761.353     -1160.1829     -1160.1829    
     62000  -8418.9494     -8418.9494     -8497.4509     -8497.4509      303.80891      303.80891      23781.245      23781.245     -3065.4719     -3065.4719    
Loop time of 63.1947 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.367 ns/day, 17.554 hours/ns, 15.824 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    | 63.113     | 63.113     | 63.113     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014787   | 0.014787   | 0.014787   |   0.0 |  0.02
Output  | 3.0026e-05 | 3.0026e-05 | 3.0026e-05 |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.10
Other   |            | 0.00524    |            |       |  0.01

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

Total # of neighbors = 212154
Ave neighs/atom = 106.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
23743.6416856691

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0