# 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.851000025868416*${_u_distance}
variable latticeconst_converted equal 2.851000025868416*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100002586842
Lattice spacing in x,y,z = 2.851 2.851 2.851
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.51 28.51 28.51)
  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.51 28.51 28.51)
  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_EtesamiAsadi_2018_Fe__MO_549900287421_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 23173.5016817912    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.5016817912/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.5016817912/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23173.5016817912/(1*1*${_u_distance})
variable      V0_metal equal 23173.5016817912/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23173.5016817912*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.5016817912 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_549900287421_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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8499.0847     -8499.0847     -8579.9999     -8579.9999      313.15         313.15         23173.502      23173.502      3729.5625      3729.5625    
      1000  -8412.6757     -8412.6757     -8493.1649     -8493.1649      311.50155      311.50155      23369.527      23369.527      2061.275       2061.275     
Loop time of 18.9776 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.553 ns/day, 5.272 hours/ns, 52.694 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 18.896     | 18.896     | 18.896     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015227   | 0.015227   | 0.015227   |   0.0 |  0.08
Output  | 0.00015136 | 0.00015136 | 0.00015136 |   0.0 |  0.00
Modify  | 0.06067    | 0.06067    | 0.06067    |   0.0 |  0.32
Other   |            | 0.005533   |            |       |  0.03

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

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8412.6757     -8412.6757     -8493.1649     -8493.1649      311.50155      311.50155      23369.527      23369.527      2061.275       2061.275     
      2000  -8414.4401     -8414.4401     -8495.5994     -8495.5994      314.09493      314.09493      23396.328      23396.328      100.94111      100.94111    
Loop time of 21.3371 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.049 ns/day, 5.927 hours/ns, 46.867 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    | 21.257     | 21.257     | 21.257     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014912   | 0.014912   | 0.014912   |   0.0 |  0.07
Output  | 5.5635e-05 | 5.5635e-05 | 5.5635e-05 |   0.0 |  0.00
Modify  | 0.059605   | 0.059605   | 0.059605   |   0.0 |  0.28
Other   |            | 0.005355   |            |       |  0.03

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

Total # of neighbors = 128230
Ave neighs/atom = 64.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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8414.4401     -8414.4401     -8495.5994     -8495.5994      314.09493      314.09493      23396.328      23396.328      100.94111      100.94111    
      3000  -8414.4962     -8414.4962     -8494.3671     -8494.3671      309.10864      309.10864      23412.039      23412.039     -1206.9894     -1206.9894    
Loop time of 21.4341 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.031 ns/day, 5.954 hours/ns, 46.655 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    | 21.354     | 21.354     | 21.354     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014826   | 0.014826   | 0.014826   |   0.0 |  0.07
Output  | 3.5547e-05 | 3.5547e-05 | 3.5547e-05 |   0.0 |  0.00
Modify  | 0.059517   | 0.059517   | 0.059517   |   0.0 |  0.28
Other   |            | 0.005298   |            |       |  0.02

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

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8414.4962     -8414.4962     -8494.3671     -8494.3671      309.10864      309.10864      23412.039      23412.039     -1206.9894     -1206.9894    
      4000  -8412.7934     -8412.7934     -8494.3769     -8494.3769      315.73679      315.73679      23410.89       23410.89      -918.58979     -918.58979    
Loop time of 21.5455 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.010 ns/day, 5.985 hours/ns, 46.413 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    | 21.465     | 21.465     | 21.465     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.07
Output  | 7.9179e-05 | 7.9179e-05 | 7.9179e-05 |   0.0 |  0.00
Modify  | 0.059668   | 0.059668   | 0.059668   |   0.0 |  0.28
Other   |            | 0.005317   |            |       |  0.02

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

Total # of neighbors = 128212
Ave neighs/atom = 64.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8412.7934     -8412.7934     -8494.3769     -8494.3769      315.73679      315.73679      23410.89       23410.89      -918.58979     -918.58979    
      5000  -8415.3081     -8415.3081     -8495.3632     -8495.3632      309.82154      309.82154      23383.652      23383.652      756.32269      756.32269    
Loop time of 21.5241 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.014 ns/day, 5.979 hours/ns, 46.460 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    | 21.444     | 21.444     | 21.444     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.07
Output  | 2.8313e-05 | 2.8313e-05 | 2.8313e-05 |   0.0 |  0.00
Modify  | 0.059727   | 0.059727   | 0.059727   |   0.0 |  0.28
Other   |            | 0.005287   |            |       |  0.02

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

Total # of neighbors = 128214
Ave neighs/atom = 64.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.139536876225, Press = 1522.65086027061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8415.3081     -8415.3081     -8495.3632     -8495.3632      309.82154      309.82154      23383.652      23383.652      756.32269      756.32269    
      6000  -8413.2609     -8413.2609     -8495.4713     -8495.4713      318.16289      318.16289      23361.654      23361.654      2534.5266      2534.5266    
Loop time of 21.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.011 ns/day, 5.983 hours/ns, 46.427 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    | 21.457     | 21.457     | 21.457     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015066   | 0.015066   | 0.015066   |   0.0 |  0.07
Output  | 2.8573e-05 | 2.8573e-05 | 2.8573e-05 |   0.0 |  0.00
Modify  | 0.061802   | 0.061802   | 0.061802   |   0.0 |  0.29
Other   |            | 0.00526    |            |       |  0.02

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

Total # of neighbors = 128252
Ave neighs/atom = 64.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.270457352559, Press = 112.991543640426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8413.2609     -8413.2609     -8495.4713     -8495.4713      318.16289      318.16289      23361.654      23361.654      2534.5266      2534.5266    
      7000  -8415.8968     -8415.8968     -8494.8899     -8494.8899      305.71136      305.71136      23344.003      23344.003      3703.8885      3703.8885    
Loop time of 21.5438 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.010 ns/day, 5.984 hours/ns, 46.417 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    | 21.462     | 21.462     | 21.462     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.07
Output  | 3.8793e-05 | 3.8793e-05 | 3.8793e-05 |   0.0 |  0.00
Modify  | 0.061844   | 0.061844   | 0.061844   |   0.0 |  0.29
Other   |            | 0.005352   |            |       |  0.02

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

Total # of neighbors = 128258
Ave neighs/atom = 64.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.212279464071, Press = 29.4933300642655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8415.8968     -8415.8968     -8494.8899     -8494.8899      305.71136      305.71136      23344.003      23344.003      3703.8885      3703.8885    
      8000  -8409.6301     -8409.6301     -8491.1551     -8491.1551      315.51023      315.51023      23383.844      23383.844      1466.0148      1466.0148    
Loop time of 21.6121 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.998 ns/day, 6.003 hours/ns, 46.270 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    | 21.53      | 21.53      | 21.53      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014999   | 0.014999   | 0.014999   |   0.0 |  0.07
Output  | 2.8513e-05 | 2.8513e-05 | 2.8513e-05 |   0.0 |  0.00
Modify  | 0.061638   | 0.061638   | 0.061638   |   0.0 |  0.29
Other   |            | 0.005192   |            |       |  0.02

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

Total # of neighbors = 128256
Ave neighs/atom = 64.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.841383797953, Press = 10.0847765894401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8409.6301     -8409.6301     -8491.1551     -8491.1551      315.51023      315.51023      23383.844      23383.844      1466.0148      1466.0148    
      9000  -8415.5697     -8415.5697     -8494.9274     -8494.9274      307.12263      307.12263      23394.514      23394.514      63.881287      63.881287    
Loop time of 21.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.015 ns/day, 5.977 hours/ns, 46.475 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    | 21.435     | 21.435     | 21.435     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.07
Output  | 3.4736e-05 | 3.4736e-05 | 3.4736e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.29
Other   |            | 0.005207   |            |       |  0.02

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

Total # of neighbors = 128358
Ave neighs/atom = 64.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910838723224, Press = 8.86680707454418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8415.5697     -8415.5697     -8494.9274     -8494.9274      307.12263      307.12263      23394.514      23394.514      63.881287      63.881287    
     10000  -8411.0107     -8411.0107     -8493.5214     -8493.5214      319.32492      319.32492      23419.867      23419.867     -1350.2012     -1350.2012    
Loop time of 21.5501 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.009 ns/day, 5.986 hours/ns, 46.403 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    | 21.468     | 21.468     | 21.468     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.07
Output  | 3.733e-05  | 3.733e-05  | 3.733e-05  |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.29
Other   |            | 0.005353   |            |       |  0.02

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.130499683781, Press = 10.4279213174691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8411.0107     -8411.0107     -8493.5214     -8493.5214      319.32492      319.32492      23419.867      23419.867     -1350.2012     -1350.2012    
     11000  -8416.4922     -8416.4922     -8497.5884     -8497.5884      313.85092      313.85092      23422.23       23422.23      -2280.5036     -2280.5036    
Loop time of 21.6249 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.007 hours/ns, 46.243 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    | 21.543     | 21.543     | 21.543     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014863   | 0.014863   | 0.014863   |   0.0 |  0.07
Output  | 4.2059e-05 | 4.2059e-05 | 4.2059e-05 |   0.0 |  0.00
Modify  | 0.061618   | 0.061618   | 0.061618   |   0.0 |  0.28
Other   |            | 0.005229   |            |       |  0.02

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

Total # of neighbors = 128266
Ave neighs/atom = 64.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.120110079881, Press = 17.3569145635958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8416.4922     -8416.4922     -8497.5884     -8497.5884      313.85092      313.85092      23422.23       23422.23      -2280.5036     -2280.5036    
     12000  -8412.3555     -8412.3555     -8495.556      -8495.556       321.9945       321.9945       23395.57       23395.57       113.03184      113.03184    
Loop time of 21.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.001 ns/day, 5.999 hours/ns, 46.303 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    | 21.515     | 21.515     | 21.515     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014906   | 0.014906   | 0.014906   |   0.0 |  0.07
Output  | 3.6759e-05 | 3.6759e-05 | 3.6759e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.29
Other   |            | 0.005228   |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.217582169014, Press = 31.4234317946008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8412.3555     -8412.3555     -8495.556      -8495.556       321.9945       321.9945       23395.57       23395.57       113.03184      113.03184    
     13000  -8413.456      -8413.456      -8493.8622     -8493.8622      311.18064      311.18064      23367.771      23367.771      2183.6768      2183.6768    
Loop time of 21.6243 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.007 hours/ns, 46.244 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    | 21.543     | 21.543     | 21.543     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014873   | 0.014873   | 0.014873   |   0.0 |  0.07
Output  | 2.9245e-05 | 2.9245e-05 | 2.9245e-05 |   0.0 |  0.00
Modify  | 0.061548   | 0.061548   | 0.061548   |   0.0 |  0.28
Other   |            | 0.005276   |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.218513360556, Press = 15.5342358437642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8413.456      -8413.456      -8493.8622     -8493.8622      311.18064      311.18064      23367.771      23367.771      2183.6768      2183.6768    
     14000  -8415.6923     -8415.6923     -8496.7774     -8496.7774      313.80757      313.80757      23374.401      23374.401      1362.8878      1362.8878    
Loop time of 21.6935 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.983 ns/day, 6.026 hours/ns, 46.097 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    | 21.612     | 21.612     | 21.612     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014835   | 0.014835   | 0.014835   |   0.0 |  0.07
Output  | 5.9611e-05 | 5.9611e-05 | 5.9611e-05 |   0.0 |  0.00
Modify  | 0.061511   | 0.061511   | 0.061511   |   0.0 |  0.28
Other   |            | 0.005193   |            |       |  0.02

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

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.34997287957, Press = 5.5744500846664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8415.6923     -8415.6923     -8496.7774     -8496.7774      313.80757      313.80757      23374.401      23374.401      1362.8878      1362.8878    
     15000  -8410.1687     -8410.1687     -8491.9886     -8491.9886      316.6515       316.6515       23402.007      23402.007      80.11088       80.11088     
Loop time of 21.5381 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.011 ns/day, 5.983 hours/ns, 46.429 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    | 21.457     | 21.457     | 21.457     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014812   | 0.014812   | 0.014812   |   0.0 |  0.07
Output  | 3.6689e-05 | 3.6689e-05 | 3.6689e-05 |   0.0 |  0.00
Modify  | 0.061529   | 0.061529   | 0.061529   |   0.0 |  0.29
Other   |            | 0.005177   |            |       |  0.02

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

Total # of neighbors = 128246
Ave neighs/atom = 64.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.275541539248, Press = 2.91598715479886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8410.1687     -8410.1687     -8491.9886     -8491.9886      316.6515       316.6515       23402.007      23402.007      80.11088       80.11088     
     16000  -8415.1962     -8415.1962     -8496.5894     -8496.5894      315.00014      315.00014      23429.046      23429.046     -2495.703      -2495.703     
Loop time of 21.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.001 ns/day, 5.998 hours/ns, 46.309 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.512     | 21.512     | 21.512     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.07
Output  | 2.8924e-05 | 2.8924e-05 | 2.8924e-05 |   0.0 |  0.00
Modify  | 0.061444   | 0.061444   | 0.061444   |   0.0 |  0.28
Other   |            | 0.005169   |            |       |  0.02

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

Total # of neighbors = 128244
Ave neighs/atom = 64.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 = 314.368926268096, Press = 1.00609795764504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8415.1962     -8415.1962     -8496.5894     -8496.5894      315.00014      315.00014      23429.046      23429.046     -2495.703      -2495.703     
     17000  -8412.1506     -8412.1506     -8494.3174     -8494.3174      317.99391      317.99391      23469.495      23469.495     -5025.0011     -5025.0011    
Loop time of 21.5931 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.001 ns/day, 5.998 hours/ns, 46.311 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    | 21.512     | 21.512     | 21.512     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014811   | 0.014811   | 0.014811   |   0.0 |  0.07
Output  | 2.9485e-05 | 2.9485e-05 | 2.9485e-05 |   0.0 |  0.00
Modify  | 0.061529   | 0.061529   | 0.061529   |   0.0 |  0.28
Other   |            | 0.005166   |            |       |  0.02

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

Total # of neighbors = 128192
Ave neighs/atom = 64.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.432491862465, Press = 6.74634770266497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8412.1506     -8412.1506     -8494.3174     -8494.3174      317.99391      317.99391      23469.495      23469.495     -5025.0011     -5025.0011    
     18000  -8413.594      -8413.594      -8496.1275     -8496.1275      319.41303      319.41303      23425.283      23425.283     -2109.3697     -2109.3697    
Loop time of 21.5896 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.002 ns/day, 5.997 hours/ns, 46.319 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.508     | 21.508     | 21.508     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014851   | 0.014851   | 0.014851   |   0.0 |  0.07
Output  | 3.6769e-05 | 3.6769e-05 | 3.6769e-05 |   0.0 |  0.00
Modify  | 0.061515   | 0.061515   | 0.061515   |   0.0 |  0.28
Other   |            | 0.005211   |            |       |  0.02

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

Total # of neighbors = 128174
Ave neighs/atom = 64.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 = 314.227811985019, Press = 10.4240104120085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8413.594      -8413.594      -8496.1275     -8496.1275      319.41303      319.41303      23425.283      23425.283     -2109.3697     -2109.3697    
     19000  -8418.6231     -8418.6231     -8497.6295     -8497.6295      305.76313      305.76313      23382.606      23382.606      576.85067      576.85067    
Loop time of 21.3796 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.041 ns/day, 5.939 hours/ns, 46.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    | 21.298     | 21.298     | 21.298     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.07
Output  | 2.8834e-05 | 2.8834e-05 | 2.8834e-05 |   0.0 |  0.00
Modify  | 0.061497   | 0.061497   | 0.061497   |   0.0 |  0.29
Other   |            | 0.005156   |            |       |  0.02

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

Total # of neighbors = 128212
Ave neighs/atom = 64.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.044215820055, Press = 9.49250655690366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8418.6231     -8418.6231     -8497.6295     -8497.6295      305.76313      305.76313      23382.606      23382.606      576.85067      576.85067    
     20000  -8415.2538     -8415.2538     -8495.9186     -8495.9186      312.18101      312.18101      23364.585      23364.585      2326.4271      2326.4271    
Loop time of 21.5796 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.004 ns/day, 5.994 hours/ns, 46.340 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    | 21.498     | 21.498     | 21.498     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.07
Output  | 2.8493e-05 | 2.8493e-05 | 2.8493e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.29
Other   |            | 0.005176   |            |       |  0.02

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

Total # of neighbors = 128186
Ave neighs/atom = 64.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.936423729353, Press = 7.97378033780276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8415.2538     -8415.2538     -8495.9186     -8495.9186      312.18101      312.18101      23364.585      23364.585      2326.4271      2326.4271    
     21000  -8413.1564     -8413.1564     -8497.6141     -8497.6141      326.85982      326.85982      23367.479      23367.479      1904.3679      1904.3679    
Loop time of 21.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.007 ns/day, 5.990 hours/ns, 46.376 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    | 21.481     | 21.481     | 21.481     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014898   | 0.014898   | 0.014898   |   0.0 |  0.07
Output  | 3.6739e-05 | 3.6739e-05 | 3.6739e-05 |   0.0 |  0.00
Modify  | 0.061663   | 0.061663   | 0.061663   |   0.0 |  0.29
Other   |            | 0.005318   |            |       |  0.02

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

Total # of neighbors = 128274
Ave neighs/atom = 64.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.99811661556, Press = 3.68447916065262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8413.1564     -8413.1564     -8497.6141     -8497.6141      326.85982      326.85982      23367.479      23367.479      1904.3679      1904.3679    
     22000  -8414.7619     -8414.7619     -8494.884      -8494.884       310.08069      310.08069      23385.118      23385.118      921.91175      921.91175    
Loop time of 21.5229 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.014 ns/day, 5.979 hours/ns, 46.462 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    | 21.441     | 21.441     | 21.441     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014832   | 0.014832   | 0.014832   |   0.0 |  0.07
Output  | 2.9635e-05 | 2.9635e-05 | 2.9635e-05 |   0.0 |  0.00
Modify  | 0.061624   | 0.061624   | 0.061624   |   0.0 |  0.29
Other   |            | 0.005291   |            |       |  0.02

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

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.881865043623, Press = 1.23456292235001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8414.7619     -8414.7619     -8494.884      -8494.884       310.08069      310.08069      23385.118      23385.118      921.91175      921.91175    
     23000  -8417.106      -8417.106      -8494.7634     -8494.7634      300.54205      300.54205      23405.041      23405.041     -705.97919     -705.97919    
Loop time of 21.5976 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.000 ns/day, 5.999 hours/ns, 46.301 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    | 21.516     | 21.516     | 21.516     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014834   | 0.014834   | 0.014834   |   0.0 |  0.07
Output  | 3.5808e-05 | 3.5808e-05 | 3.5808e-05 |   0.0 |  0.00
Modify  | 0.061662   | 0.061662   | 0.061662   |   0.0 |  0.29
Other   |            | 0.005294   |            |       |  0.02

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

Total # of neighbors = 128232
Ave neighs/atom = 64.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8285792089, Press = -2.05832852091215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8417.106      -8417.106      -8494.7634     -8494.7634      300.54205      300.54205      23405.041      23405.041     -705.97919     -705.97919    
     24000  -8411.3955     -8411.3955     -8494.0408     -8494.0408      319.84589      319.84589      23445.028      23445.028     -3287.2067     -3287.2067    
Loop time of 21.6276 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.008 hours/ns, 46.237 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    | 21.546     | 21.546     | 21.546     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014855   | 0.014855   | 0.014855   |   0.0 |  0.07
Output  | 2.9225e-05 | 2.9225e-05 | 2.9225e-05 |   0.0 |  0.00
Modify  | 0.0617     | 0.0617     | 0.0617     |   0.0 |  0.29
Other   |            | 0.005315   |            |       |  0.02

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

Total # of neighbors = 128204
Ave neighs/atom = 64.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.745755877365, Press = 0.955293706489013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8411.3955     -8411.3955     -8494.0408     -8494.0408      319.84589      319.84589      23445.028      23445.028     -3287.2067     -3287.2067    
     25000  -8414.518      -8414.518      -8492.1108     -8492.1108      300.2919       300.2919       23427.219      23427.219     -1923.1406     -1923.1406    
Loop time of 21.6711 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.987 ns/day, 6.020 hours/ns, 46.144 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    | 21.589     | 21.589     | 21.589     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.07
Output  | 2.9345e-05 | 2.9345e-05 | 2.9345e-05 |   0.0 |  0.00
Modify  | 0.061489   | 0.061489   | 0.061489   |   0.0 |  0.28
Other   |            | 0.005289   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.699142747198, Press = 3.88622245383684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8414.518      -8414.518      -8492.1108     -8492.1108      300.2919       300.2919       23427.219      23427.219     -1923.1406     -1923.1406    
     26000  -8416.0261     -8416.0261     -8497.9816     -8497.9816      317.17641      317.17641      23413.51       23413.51      -1658.908      -1658.908     
Loop time of 21.5618 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.007 ns/day, 5.989 hours/ns, 46.378 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    | 21.479     | 21.479     | 21.479     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014884   | 0.014884   | 0.014884   |   0.0 |  0.07
Output  | 3.6859e-05 | 3.6859e-05 | 3.6859e-05 |   0.0 |  0.00
Modify  | 0.062154   | 0.062154   | 0.062154   |   0.0 |  0.29
Other   |            | 0.005313   |            |       |  0.02

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

Total # of neighbors = 128298
Ave neighs/atom = 64.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.74028945566, Press = 5.25299435230329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8416.0261     -8416.0261     -8497.9816     -8497.9816      317.17641      317.17641      23413.51       23413.51      -1658.908      -1658.908     
     27000  -8413.0339     -8413.0339     -8493.2532     -8493.2532      310.45707      310.45707      23395.589      23395.589      260.69941      260.69941    
Loop time of 21.6393 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.993 ns/day, 6.011 hours/ns, 46.212 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    | 21.558     | 21.558     | 21.558     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014812   | 0.014812   | 0.014812   |   0.0 |  0.07
Output  | 2.8383e-05 | 2.8383e-05 | 2.8383e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.28
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128254
Ave neighs/atom = 64.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.675507927078, Press = 5.8747044490028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8413.0339     -8413.0339     -8493.2532     -8493.2532      310.45707      310.45707      23395.589      23395.589      260.69941      260.69941    
     28000  -8415.8019     -8415.8019     -8494.6023     -8494.6023      304.96547      304.96547      23367.85       23367.85       1967.2927      1967.2927    
Loop time of 21.4819 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.022 ns/day, 5.967 hours/ns, 46.551 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    | 21.4       | 21.4       | 21.4       |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014809   | 0.014809   | 0.014809   |   0.0 |  0.07
Output  | 2.9465e-05 | 2.9465e-05 | 2.9465e-05 |   0.0 |  0.00
Modify  | 0.061548   | 0.061548   | 0.061548   |   0.0 |  0.29
Other   |            | 0.005285   |            |       |  0.02

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

Total # of neighbors = 128260
Ave neighs/atom = 64.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.678444222529, Press = 6.34232222978225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8415.8019     -8415.8019     -8494.6023     -8494.6023      304.96547      304.96547      23367.85       23367.85       1967.2927      1967.2927    
     29000  -8413.7058     -8413.7058     -8495.3479     -8495.3479      315.96343      315.96343      23322.762      23322.762      5370.3242      5370.3242    
Loop time of 21.6682 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.987 ns/day, 6.019 hours/ns, 46.150 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    | 21.587     | 21.587     | 21.587     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014884   | 0.014884   | 0.014884   |   0.0 |  0.07
Output  | 3.7961e-05 | 3.7961e-05 | 3.7961e-05 |   0.0 |  0.00
Modify  | 0.061591   | 0.061591   | 0.061591   |   0.0 |  0.28
Other   |            | 0.00522    |            |       |  0.02

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

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.62334566697, Press = 4.77563741515524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8413.7058     -8413.7058     -8495.3479     -8495.3479      315.96343      315.96343      23322.762      23322.762      5370.3242      5370.3242    
     30000  -8413.1553     -8413.1553     -8493.1732     -8493.1732      309.67757      309.67757      23365.568      23365.568      2457.2825      2457.2825    
Loop time of 21.679 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.022 hours/ns, 46.128 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    | 21.597     | 21.597     | 21.597     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014923   | 0.014923   | 0.014923   |   0.0 |  0.07
Output  | 2.7762e-05 | 2.7762e-05 | 2.7762e-05 |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.28
Other   |            | 0.005158   |            |       |  0.02

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

Total # of neighbors = 128304
Ave neighs/atom = 64.152
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.599008666781, Press = 1.75209882728296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8413.1553     -8413.1553     -8493.1732     -8493.1732      309.67757      309.67757      23365.568      23365.568      2457.2825      2457.2825    
     31000  -8416.6058     -8416.6058     -8495.8258     -8495.8258      306.5895       306.5895       23391.972      23391.972      73.246821      73.246821    
Loop time of 21.7093 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.030 hours/ns, 46.063 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    | 21.628     | 21.628     | 21.628     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014879   | 0.014879   | 0.014879   |   0.0 |  0.07
Output  | 2.8604e-05 | 2.8604e-05 | 2.8604e-05 |   0.0 |  0.00
Modify  | 0.061637   | 0.061637   | 0.061637   |   0.0 |  0.28
Other   |            | 0.005167   |            |       |  0.02

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

Total # of neighbors = 128272
Ave neighs/atom = 64.136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.558106363398, Press = 0.637091889677622
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8416.6058     -8416.6058     -8495.8258     -8495.8258      306.5895       306.5895       23391.972      23391.972      73.246821      73.246821    
     32000  -8412.5178     -8412.5178     -8494.5394     -8494.5394      317.43227      317.43227      23416.833      23416.833     -1383.7281     -1383.7281    
Loop time of 21.6469 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.991 ns/day, 6.013 hours/ns, 46.196 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    | 21.565     | 21.565     | 21.565     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.07
Output  | 3.751e-05  | 3.751e-05  | 3.751e-05  |   0.0 |  0.00
Modify  | 0.061613   | 0.061613   | 0.061613   |   0.0 |  0.28
Other   |            | 0.005186   |            |       |  0.02

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

Total # of neighbors = 128266
Ave neighs/atom = 64.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.46704614109, Press = 2.02246108910012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8412.5178     -8412.5178     -8494.5394     -8494.5394      317.43227      317.43227      23416.833      23416.833     -1383.7281     -1383.7281    
     33000  -8412.4906     -8412.4906     -8493.361      -8493.361       312.97653      312.97653      23429.414      23429.414     -2105.8102     -2105.8102    
Loop time of 21.5071 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.017 ns/day, 5.974 hours/ns, 46.496 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    | 21.425     | 21.425     | 21.425     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.07
Output  | 2.8914e-05 | 2.8914e-05 | 2.8914e-05 |   0.0 |  0.00
Modify  | 0.06155    | 0.06155    | 0.06155    |   0.0 |  0.29
Other   |            | 0.005175   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.472651298541, Press = 3.17004905510207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8412.4906     -8412.4906     -8493.361      -8493.361       312.97653      312.97653      23429.414      23429.414     -2105.8102     -2105.8102    
     34000  -8416.9051     -8416.9051     -8497.8019     -8497.8019      313.07916      313.07916      23437.305      23437.305     -3398.7788     -3398.7788    
Loop time of 21.5609 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.007 ns/day, 5.989 hours/ns, 46.380 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    | 21.479     | 21.479     | 21.479     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014797   | 0.014797   | 0.014797   |   0.0 |  0.07
Output  | 2.8964e-05 | 2.8964e-05 | 2.8964e-05 |   0.0 |  0.00
Modify  | 0.061534   | 0.061534   | 0.061534   |   0.0 |  0.29
Other   |            | 0.005254   |            |       |  0.02

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

Total # of neighbors = 128230
Ave neighs/atom = 64.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.427195095334, Press = 6.01451118564988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8416.9051     -8416.9051     -8497.8019     -8497.8019      313.07916      313.07916      23437.305      23437.305     -3398.7788     -3398.7788    
     35000  -8413.1017     -8413.1017     -8493.4615     -8493.4615      311.00065      311.00065      23397.633      23397.633      122.49065      122.49065    
Loop time of 21.5764 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.004 ns/day, 5.993 hours/ns, 46.347 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    | 21.495     | 21.495     | 21.495     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014867   | 0.014867   | 0.014867   |   0.0 |  0.07
Output  | 3.8722e-05 | 3.8722e-05 | 3.8722e-05 |   0.0 |  0.00
Modify  | 0.061564   | 0.061564   | 0.061564   |   0.0 |  0.29
Other   |            | 0.005296   |            |       |  0.02

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

Total # of neighbors = 128178
Ave neighs/atom = 64.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40694909749, Press = 5.89245488592659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8413.1017     -8413.1017     -8493.4615     -8493.4615      311.00065      311.00065      23397.633      23397.633      122.49065      122.49065    
     36000  -8414.6127     -8414.6127     -8497.0087     -8497.0087      318.88087      318.88087      23383.998      23383.998      673.13382      673.13382    
Loop time of 21.6572 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.989 ns/day, 6.016 hours/ns, 46.174 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    | 21.575     | 21.575     | 21.575     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014917   | 0.014917   | 0.014917   |   0.0 |  0.07
Output  | 2.8343e-05 | 2.8343e-05 | 2.8343e-05 |   0.0 |  0.00
Modify  | 0.06155    | 0.06155    | 0.06155    |   0.0 |  0.28
Other   |            | 0.005258   |            |       |  0.02

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

Total # of neighbors = 128252
Ave neighs/atom = 64.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41065221205, Press = 4.04483634596809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8414.6127     -8414.6127     -8497.0087     -8497.0087      318.88087      318.88087      23383.998      23383.998      673.13382      673.13382    
     37000  -8409.9075     -8409.9075     -8490.8037     -8490.8037      313.07636      313.07636      23380.884      23380.884      1849.3052      1849.3052    
Loop time of 21.5724 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.005 ns/day, 5.992 hours/ns, 46.355 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    | 21.491     | 21.491     | 21.491     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01482    | 0.01482    | 0.01482    |   0.0 |  0.07
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.061616   | 0.061616   | 0.061616   |   0.0 |  0.29
Other   |            | 0.005182   |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.454680014035, Press = 3.13310622947678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8409.9075     -8409.9075     -8490.8037     -8490.8037      313.07636      313.07636      23380.884      23380.884      1849.3052      1849.3052    
     38000  -8414.9143     -8414.9143     -8495.3271     -8495.3271      311.20574      311.20574      23367.708      23367.708      2103.5137      2103.5137    
Loop time of 21.5976 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.000 ns/day, 5.999 hours/ns, 46.302 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.516     | 21.516     | 21.516     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.07
Output  | 2.8714e-05 | 2.8714e-05 | 2.8714e-05 |   0.0 |  0.00
Modify  | 0.061512   | 0.061512   | 0.061512   |   0.0 |  0.28
Other   |            | 0.005159   |            |       |  0.02

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

Total # of neighbors = 128320
Ave neighs/atom = 64.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511940158496, Press = 1.85294519425609
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8414.9143     -8414.9143     -8495.3271     -8495.3271      311.20574      311.20574      23367.708      23367.708      2103.5137      2103.5137    
     39000  -8408.0146     -8408.0146     -8491.4605     -8491.4605      322.94437      322.94437      23387.807      23387.807      1480.6508      1480.6508    
Loop time of 21.6562 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.016 hours/ns, 46.176 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    | 21.575     | 21.575     | 21.575     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014849   | 0.014849   | 0.014849   |   0.0 |  0.07
Output  | 2.8924e-05 | 2.8924e-05 | 2.8924e-05 |   0.0 |  0.00
Modify  | 0.061456   | 0.061456   | 0.061456   |   0.0 |  0.28
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128252
Ave neighs/atom = 64.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.557244674513, Press = -0.149819442957414
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8408.0146     -8408.0146     -8491.4605     -8491.4605      322.94437      322.94437      23387.807      23387.807      1480.6508      1480.6508    
     40000  -8414.6076     -8414.6076     -8495.6958     -8495.6958      313.81981      313.81981      23410.741      23410.741     -1018.0742     -1018.0742    
Loop time of 21.6611 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.989 ns/day, 6.017 hours/ns, 46.166 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    | 21.579     | 21.579     | 21.579     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014852   | 0.014852   | 0.014852   |   0.0 |  0.07
Output  | 3.8091e-05 | 3.8091e-05 | 3.8091e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.28
Other   |            | 0.005229   |            |       |  0.02

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

Total # of neighbors = 128286
Ave neighs/atom = 64.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.594146316382, Press = 0.558922902058885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8414.6076     -8414.6076     -8495.6958     -8495.6958      313.81981      313.81981      23410.741      23410.741     -1018.0742     -1018.0742    
     41000  -8412.9518     -8412.9518     -8492.8434     -8492.8434      309.1886       309.1886       23418.529      23418.529     -1382.4879     -1382.4879    
Loop time of 21.6005 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.000 ns/day, 6.000 hours/ns, 46.295 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    | 21.519     | 21.519     | 21.519     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.07
Output  | 2.9365e-05 | 2.9365e-05 | 2.9365e-05 |   0.0 |  0.00
Modify  | 0.061569   | 0.061569   | 0.061569   |   0.0 |  0.29
Other   |            | 0.00525    |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.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 = 313.627963282434, Press = 2.02658035211214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8412.9518     -8412.9518     -8492.8434     -8492.8434      309.1886       309.1886       23418.529      23418.529     -1382.4879     -1382.4879    
     42000  -8412.5362     -8412.5362     -8494.2899     -8494.2899      316.39545      316.39545      23418.902      23418.902     -1413.7643     -1413.7643    
Loop time of 21.5665 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.991 hours/ns, 46.368 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    | 21.485     | 21.485     | 21.485     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014856   | 0.014856   | 0.014856   |   0.0 |  0.07
Output  | 2.8123e-05 | 2.8123e-05 | 2.8123e-05 |   0.0 |  0.00
Modify  | 0.06152    | 0.06152    | 0.06152    |   0.0 |  0.29
Other   |            | 0.005163   |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.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 = 313.629811080982, Press = 2.58837965531159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8412.5362     -8412.5362     -8494.2899     -8494.2899      316.39545      316.39545      23418.902      23418.902     -1413.7643     -1413.7643    
     43000  -8413.135      -8413.135      -8495.8228     -8495.8228      320.01025      320.01025      23420.459      23420.459     -1772.9425     -1772.9425    
Loop time of 21.6526 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.015 hours/ns, 46.184 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    | 21.571     | 21.571     | 21.571     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.07
Output  | 3.7811e-05 | 3.7811e-05 | 3.7811e-05 |   0.0 |  0.00
Modify  | 0.06152    | 0.06152    | 0.06152    |   0.0 |  0.28
Other   |            | 0.005158   |            |       |  0.02

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

Total # of neighbors = 128238
Ave neighs/atom = 64.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.699156318425, Press = 2.74368422751722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8413.135      -8413.135      -8495.8228     -8495.8228      320.01025      320.01025      23420.459      23420.459     -1772.9425     -1772.9425    
     44000  -8412.0901     -8412.0901     -8494.0043     -8494.0043      317.01656      317.01656      23427.313      23427.313     -1965.6555     -1965.6555    
Loop time of 21.5995 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.000 ns/day, 6.000 hours/ns, 46.297 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    | 21.518     | 21.518     | 21.518     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014906   | 0.014906   | 0.014906   |   0.0 |  0.07
Output  | 2.7682e-05 | 2.7682e-05 | 2.7682e-05 |   0.0 |  0.00
Modify  | 0.061526   | 0.061526   | 0.061526   |   0.0 |  0.28
Other   |            | 0.005172   |            |       |  0.02

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

Total # of neighbors = 128190
Ave neighs/atom = 64.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.71591843999, Press = 3.77859974805458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8412.0901     -8412.0901     -8494.0043     -8494.0043      317.01656      317.01656      23427.313      23427.313     -1965.6555     -1965.6555    
     45000  -8416.781      -8416.781      -8495.9687     -8495.9687      306.46461      306.46461      23384.702      23384.702      640.6626       640.6626     
Loop time of 21.6294 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.008 hours/ns, 46.233 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    | 21.548     | 21.548     | 21.548     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014844   | 0.014844   | 0.014844   |   0.0 |  0.07
Output  | 3.5827e-05 | 3.5827e-05 | 3.5827e-05 |   0.0 |  0.00
Modify  | 0.061596   | 0.061596   | 0.061596   |   0.0 |  0.28
Other   |            | 0.005152   |            |       |  0.02

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

Total # of neighbors = 128220
Ave neighs/atom = 64.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.747375500219, Press = 5.19508621741611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8416.781      -8416.781      -8495.9687     -8495.9687      306.46461      306.46461      23384.702      23384.702      640.6626       640.6626     
     46000  -8413.0877     -8413.0877     -8494.8223     -8494.8223      316.32148      316.32148      23363.54       23363.54       2487.2419      2487.2419    
Loop time of 21.7426 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.974 ns/day, 6.040 hours/ns, 45.993 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    | 21.661     | 21.661     | 21.661     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.07
Output  | 3.732e-05  | 3.732e-05  | 3.732e-05  |   0.0 |  0.00
Modify  | 0.061836   | 0.061836   | 0.061836   |   0.0 |  0.28
Other   |            | 0.005221   |            |       |  0.02

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

Total # of neighbors = 128210
Ave neighs/atom = 64.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.690863268396, Press = 3.56192456900796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8413.0877     -8413.0877     -8494.8223     -8494.8223      316.32148      316.32148      23363.54       23363.54       2487.2419      2487.2419    
     47000  -8412.3615     -8412.3615     -8495.4987     -8495.4987      321.74937      321.74937      23376.935      23376.935      1529.5758      1529.5758    
Loop time of 21.7208 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.034 hours/ns, 46.039 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    | 21.639     | 21.639     | 21.639     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014897   | 0.014897   | 0.014897   |   0.0 |  0.07
Output  | 2.9796e-05 | 2.9796e-05 | 2.9796e-05 |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.28
Other   |            | 0.005186   |            |       |  0.02

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

Total # of neighbors = 128244
Ave neighs/atom = 64.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.666867246819, Press = 1.89937363191162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8412.3615     -8412.3615     -8495.4987     -8495.4987      321.74937      321.74937      23376.935      23376.935      1529.5758      1529.5758    
     48000  -8416.0664     -8416.0664     -8495.1812     -8495.1812      306.1825       306.1825       23385.309      23385.309      753.72254      753.72254    
Loop time of 21.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.031 hours/ns, 46.060 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    | 21.629     | 21.629     | 21.629     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014874   | 0.014874   | 0.014874   |   0.0 |  0.07
Output  | 3.5676e-05 | 3.5676e-05 | 3.5676e-05 |   0.0 |  0.00
Modify  | 0.061763   | 0.061763   | 0.061763   |   0.0 |  0.28
Other   |            | 0.005178   |            |       |  0.02

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

Total # of neighbors = 128244
Ave neighs/atom = 64.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.625826440601, Press = 1.60805391302989
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8416.0664     -8416.0664     -8495.1812     -8495.1812      306.1825       306.1825       23385.309      23385.309      753.72254      753.72254    
     49000  -8414.9772     -8414.9772     -8496.301      -8496.301       314.73124      314.73124      23399.805      23399.805     -469.56901     -469.56901    
Loop time of 21.7112 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.031 hours/ns, 46.059 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    | 21.629     | 21.629     | 21.629     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014966   | 0.014966   | 0.014966   |   0.0 |  0.07
Output  | 2.9135e-05 | 2.9135e-05 | 2.9135e-05 |   0.0 |  0.00
Modify  | 0.061846   | 0.061846   | 0.061846   |   0.0 |  0.28
Other   |            | 0.005186   |            |       |  0.02

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

Total # of neighbors = 128164
Ave neighs/atom = 64.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.614344572142, Press = 1.18796448120744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8414.9772     -8414.9772     -8496.301      -8496.301       314.73124      314.73124      23399.805      23399.805     -469.56901     -469.56901    
     50000  -8413.4458     -8413.4458     -8494.2045     -8494.2045      312.54432      312.54432      23427.955      23427.955     -2198.2541     -2198.2541    
Loop time of 21.6847 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.024 hours/ns, 46.116 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    | 21.603     | 21.603     | 21.603     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.07
Output  | 2.9465e-05 | 2.9465e-05 | 2.9465e-05 |   0.0 |  0.00
Modify  | 0.061749   | 0.061749   | 0.061749   |   0.0 |  0.28
Other   |            | 0.005257   |            |       |  0.02

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

Total # of neighbors = 128234
Ave neighs/atom = 64.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.538666569599, Press = 0.966537065177624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8413.4458     -8413.4458     -8494.2045     -8494.2045      312.54432      312.54432      23427.955      23427.955     -2198.2541     -2198.2541    
     51000  -8416.5089     -8416.5089     -8494.7455     -8494.7455      302.78366      302.78366      23448.054      23448.054     -3899.0431     -3899.0431    
Loop time of 21.8298 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.958 ns/day, 6.064 hours/ns, 45.809 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    | 21.748     | 21.748     | 21.748     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.07
Output  | 3.694e-05  | 3.694e-05  | 3.694e-05  |   0.0 |  0.00
Modify  | 0.061781   | 0.061781   | 0.061781   |   0.0 |  0.28
Other   |            | 0.005272   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.48938688615, Press = 2.27019364082533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8416.5089     -8416.5089     -8494.7455     -8494.7455      302.78366      302.78366      23448.054      23448.054     -3899.0431     -3899.0431    
     52000  -8407.991      -8407.991      -8492.1176     -8492.1176      325.57851      325.57851      23434.849      23434.849     -2181.4923     -2181.4923    
Loop time of 21.7514 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.972 ns/day, 6.042 hours/ns, 45.974 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    | 21.669     | 21.669     | 21.669     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.07
Output  | 2.9656e-05 | 2.9656e-05 | 2.9656e-05 |   0.0 |  0.00
Modify  | 0.061825   | 0.061825   | 0.061825   |   0.0 |  0.28
Other   |            | 0.005185   |            |       |  0.02

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

Total # of neighbors = 128200
Ave neighs/atom = 64.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.490756797944, Press = 2.9772889477293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8407.991      -8407.991      -8492.1176     -8492.1176      325.57851      325.57851      23434.849      23434.849     -2181.4923     -2181.4923    
     53000  -8414.5218     -8414.5218     -8493.4148     -8493.4148      305.32392      305.32392      23404.89       23404.89      -378.57447     -378.57447    
Loop time of 21.71 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.031 hours/ns, 46.062 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    | 21.628     | 21.628     | 21.628     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.07
Output  | 2.8724e-05 | 2.8724e-05 | 2.8724e-05 |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.28
Other   |            | 0.005202   |            |       |  0.02

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

Total # of neighbors = 128250
Ave neighs/atom = 64.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.504755277926, Press = 2.94202355826101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8414.5218     -8414.5218     -8493.4148     -8493.4148      305.32392      305.32392      23404.89       23404.89      -378.57447     -378.57447    
     54000  -8409.1191     -8409.1191     -8490.4147     -8490.4147      314.62241      314.62241      23393.889      23393.889      911.69732      911.69732    
Loop time of 21.8248 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.959 ns/day, 6.062 hours/ns, 45.819 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    | 21.743     | 21.743     | 21.743     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.07
Output  | 3.7621e-05 | 3.7621e-05 | 3.7621e-05 |   0.0 |  0.00
Modify  | 0.061739   | 0.061739   | 0.061739   |   0.0 |  0.28
Other   |            | 0.005188   |            |       |  0.02

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

Total # of neighbors = 128240
Ave neighs/atom = 64.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.544745256605, Press = 2.97183742570159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8409.1191     -8409.1191     -8490.4147     -8490.4147      314.62241      314.62241      23393.889      23393.889      911.69732      911.69732    
     55000  -8413.8281     -8413.8281     -8497.1011     -8497.1011      322.27509      322.27509      23370.25       23370.25       1772.4627      1772.4627    
Loop time of 21.8759 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.950 ns/day, 6.077 hours/ns, 45.712 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    | 21.794     | 21.794     | 21.794     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014885   | 0.014885   | 0.014885   |   0.0 |  0.07
Output  | 2.9435e-05 | 2.9435e-05 | 2.9435e-05 |   0.0 |  0.00
Modify  | 0.061804   | 0.061804   | 0.061804   |   0.0 |  0.28
Other   |            | 0.00518    |            |       |  0.02

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

Total # of neighbors = 128262
Ave neighs/atom = 64.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.55502116481, Press = 2.59945294646592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8413.8281     -8413.8281     -8497.1011     -8497.1011      322.27509      322.27509      23370.25       23370.25       1772.4627      1772.4627    
     56000  -8417.4175     -8417.4175     -8495.8274     -8495.8274      303.45423      303.45423      23359.022      23359.022      2541.5606      2541.5606    
Loop time of 21.7562 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.971 ns/day, 6.043 hours/ns, 45.964 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    | 21.674     | 21.674     | 21.674     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014832   | 0.014832   | 0.014832   |   0.0 |  0.07
Output  | 3.2692e-05 | 3.2692e-05 | 3.2692e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.28
Other   |            | 0.005201   |            |       |  0.02

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542227286576, Press = 1.27306921764682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8417.4175     -8417.4175     -8495.8274     -8495.8274      303.45423      303.45423      23359.022      23359.022      2541.5606      2541.5606    
     57000  -8414.0591     -8414.0591     -8494.8557     -8494.8557      312.69122      312.69122      23383.567      23383.567      907.91108      907.91108    
Loop time of 21.7205 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.033 hours/ns, 46.039 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    | 21.639     | 21.639     | 21.639     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.07
Output  | 3.758e-05  | 3.758e-05  | 3.758e-05  |   0.0 |  0.00
Modify  | 0.061846   | 0.061846   | 0.061846   |   0.0 |  0.28
Other   |            | 0.005216   |            |       |  0.02

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

Total # of neighbors = 128208
Ave neighs/atom = 64.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.534711540975, Press = 0.547311882102407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8414.0591     -8414.0591     -8494.8557     -8494.8557      312.69122      312.69122      23383.567      23383.567      907.91108      907.91108    
     58000  -8416.4453     -8416.4453     -8497.5091     -8497.5091      313.72562      313.72562      23411.959      23411.959     -1497.8081     -1497.8081    
Loop time of 21.7164 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.979 ns/day, 6.032 hours/ns, 46.048 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    | 21.635     | 21.635     | 21.635     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014895   | 0.014895   | 0.014895   |   0.0 |  0.07
Output  | 2.9365e-05 | 2.9365e-05 | 2.9365e-05 |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.28
Other   |            | 0.005184   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.512489557679, Press = 0.342213991827194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8416.4453     -8416.4453     -8497.5091     -8497.5091      313.72562      313.72562      23411.959      23411.959     -1497.8081     -1497.8081    
     59000  -8412.5559     -8412.5559     -8493.4268     -8493.4268      312.97871      312.97871      23428.729      23428.729     -1950.7866     -1950.7866    
Loop time of 21.6521 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.014 hours/ns, 46.185 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    | 21.57      | 21.57      | 21.57      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.07
Output  | 3.5015e-05 | 3.5015e-05 | 3.5015e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.29
Other   |            | 0.005193   |            |       |  0.02

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

Total # of neighbors = 128192
Ave neighs/atom = 64.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.459166857278, Press = 1.12007702942668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8412.5559     -8412.5559     -8493.4268     -8493.4268      312.97871      312.97871      23428.729      23428.729     -1950.7866     -1950.7866    
     60000  -8414.8918     -8414.8918     -8495.3509     -8495.3509      311.38533      311.38533      23410.072      23410.072     -1042.2136     -1042.2136    
Loop time of 21.7171 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.033 hours/ns, 46.047 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    | 21.635     | 21.635     | 21.635     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.07
Output  | 2.9395e-05 | 2.9395e-05 | 2.9395e-05 |   0.0 |  0.00
Modify  | 0.06167    | 0.06167    | 0.06167    |   0.0 |  0.28
Other   |            | 0.005193   |            |       |  0.02

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

Total # of neighbors = 128182
Ave neighs/atom = 64.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.438809504793, Press = 2.09382426070024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8414.8918     -8414.8918     -8495.3509     -8495.3509      311.38533      311.38533      23410.072      23410.072     -1042.2136     -1042.2136    
     61000  -8411.953      -8411.953      -8494.4637     -8494.4637      319.32507      319.32507      23395.676      23395.676      304.08017      304.08017    
Loop time of 21.7615 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.970 ns/day, 6.045 hours/ns, 45.953 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    | 21.68      | 21.68      | 21.68      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014875   | 0.014875   | 0.014875   |   0.0 |  0.07
Output  | 2.8965e-05 | 2.8965e-05 | 2.8965e-05 |   0.0 |  0.00
Modify  | 0.06179    | 0.06179    | 0.06179    |   0.0 |  0.28
Other   |            | 0.005185   |            |       |  0.02

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

Total # of neighbors = 128244
Ave neighs/atom = 64.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.430931922255, Press = 2.45541729883465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8411.953      -8411.953      -8494.4637     -8494.4637      319.32507      319.32507      23395.676      23395.676      304.08017      304.08017    
     62000  -8415.8206     -8415.8206     -8497.148      -8497.148       314.74519      314.74519      23371.347      23371.347      1618.8089      1618.8089    
Loop time of 21.7331 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.037 hours/ns, 46.013 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    | 21.651     | 21.651     | 21.651     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.07
Output  | 6.1996e-05 | 6.1996e-05 | 6.1996e-05 |   0.0 |  0.00
Modify  | 0.06183    | 0.06183    | 0.06183    |   0.0 |  0.28
Other   |            | 0.005219   |            |       |  0.02

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383717365542, Press = 2.28972723775062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8415.8206     -8415.8206     -8497.148      -8497.148       314.74519      314.74519      23371.347      23371.347      1618.8089      1618.8089    
     63000  -8413.7154     -8413.7154     -8494.637      -8494.637       313.17473      313.17473      23375.712      23375.712      1682.0384      1682.0384    
Loop time of 21.6886 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.025 hours/ns, 46.107 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    | 21.607     | 21.607     | 21.607     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014862   | 0.014862   | 0.014862   |   0.0 |  0.07
Output  | 3.4995e-05 | 3.4995e-05 | 3.4995e-05 |   0.0 |  0.00
Modify  | 0.061799   | 0.061799   | 0.061799   |   0.0 |  0.28
Other   |            | 0.0052     |            |       |  0.02

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

Total # of neighbors = 128234
Ave neighs/atom = 64.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.356845283145, Press = 1.03632605280675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8413.7154     -8413.7154     -8494.637      -8494.637       313.17473      313.17473      23375.712      23375.712      1682.0384      1682.0384    
     64000  -8416.284      -8416.284      -8496.2554     -8496.2554      309.49758      309.49758      23392.824      23392.824      97.512761      97.512761    
Loop time of 21.8259 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.959 ns/day, 6.063 hours/ns, 45.817 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    | 21.744     | 21.744     | 21.744     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014808   | 0.014808   | 0.014808   |   0.0 |  0.07
Output  | 2.8473e-05 | 2.8473e-05 | 2.8473e-05 |   0.0 |  0.00
Modify  | 0.061759   | 0.061759   | 0.061759   |   0.0 |  0.28
Other   |            | 0.005312   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.311806400938, Press = -0.213234454822392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8416.284      -8416.284      -8496.2554     -8496.2554      309.49758      309.49758      23392.824      23392.824      97.512761      97.512761    
     65000  -8415.1944     -8415.1944     -8493.7576     -8493.7576      304.04752      304.04752      23423.297      23423.297     -1772.8985     -1772.8985    
Loop time of 21.7814 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.967 ns/day, 6.050 hours/ns, 45.911 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    | 21.699     | 21.699     | 21.699     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014831   | 0.014831   | 0.014831   |   0.0 |  0.07
Output  | 3.9013e-05 | 3.9013e-05 | 3.9013e-05 |   0.0 |  0.00
Modify  | 0.061774   | 0.061774   | 0.061774   |   0.0 |  0.28
Other   |            | 0.005313   |            |       |  0.02

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

Total # of neighbors = 128204
Ave neighs/atom = 64.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.340830127941, Press = 0.539899182221548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8415.1944     -8415.1944     -8493.7576     -8493.7576      304.04752      304.04752      23423.297      23423.297     -1772.8985     -1772.8985    
     66000  -8411.4299     -8411.4299     -8492.5583     -8492.5583      313.97504      313.97504      23432.594      23432.594     -2133.5889     -2133.5889    
Loop time of 21.7918 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.889 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    | 21.71      | 21.71      | 21.71      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.07
Output  | 2.8023e-05 | 2.8023e-05 | 2.8023e-05 |   0.0 |  0.00
Modify  | 0.061663   | 0.061663   | 0.061663   |   0.0 |  0.28
Other   |            | 0.005175   |            |       |  0.02

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

Total # of neighbors = 128228
Ave neighs/atom = 64.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358627691415, Press = 1.65422991611536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8411.4299     -8411.4299     -8492.5583     -8492.5583      313.97504      313.97504      23432.594      23432.594     -2133.5889     -2133.5889    
     67000  -8412.7498     -8412.7498     -8494.3483     -8494.3483      315.79463      315.79463      23419.856      23419.856     -1608.2766     -1608.2766    
Loop time of 21.7239 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.034 hours/ns, 46.032 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    | 21.642     | 21.642     | 21.642     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.07
Output  | 2.8834e-05 | 2.8834e-05 | 2.8834e-05 |   0.0 |  0.00
Modify  | 0.061717   | 0.061717   | 0.061717   |   0.0 |  0.28
Other   |            | 0.005204   |            |       |  0.02

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

Total # of neighbors = 128218
Ave neighs/atom = 64.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.406509221926, Press = 2.11179110333031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8412.7498     -8412.7498     -8494.3483     -8494.3483      315.79463      315.79463      23419.856      23419.856     -1608.2766     -1608.2766    
     68000  -8413.3732     -8413.3732     -8494.1588     -8494.1588      312.64885      312.64885      23407.183      23407.183     -574.42524     -574.42524    
Loop time of 21.6554 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.015 hours/ns, 46.178 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    | 21.574     | 21.574     | 21.574     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.07
Output  | 3.6869e-05 | 3.6869e-05 | 3.6869e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.28
Other   |            | 0.005206   |            |       |  0.02

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

Total # of neighbors = 128256
Ave neighs/atom = 64.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405130058995, Press = 2.08269673494617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8413.3732     -8413.3732     -8494.1588     -8494.1588      312.64885      312.64885      23407.183      23407.183     -574.42524     -574.42524    
     69000  -8414.3139     -8414.3139     -8494.7175     -8494.7175      311.1703       311.1703       23403.98       23403.98      -425.81902     -425.81902    
Loop time of 21.7629 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.970 ns/day, 6.045 hours/ns, 45.950 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    | 21.681     | 21.681     | 21.681     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014861   | 0.014861   | 0.014861   |   0.0 |  0.07
Output  | 2.8784e-05 | 2.8784e-05 | 2.8784e-05 |   0.0 |  0.00
Modify  | 0.061851   | 0.061851   | 0.061851   |   0.0 |  0.28
Other   |            | 0.005193   |            |       |  0.02

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

Total # of neighbors = 128234
Ave neighs/atom = 64.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.43231455052, Press = 1.77505099781458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8414.3139     -8414.3139     -8494.7175     -8494.7175      311.1703       311.1703       23403.98       23403.98      -425.81902     -425.81902    
     70000  -8409.0911     -8409.0911     -8492.1822     -8492.1822      321.57138      321.57138      23409.986      23409.986     -390.2902      -390.2902     
Loop time of 21.8463 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.955 ns/day, 6.068 hours/ns, 45.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    | 21.764     | 21.764     | 21.764     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015092   | 0.015092   | 0.015092   |   0.0 |  0.07
Output  | 2.8694e-05 | 2.8694e-05 | 2.8694e-05 |   0.0 |  0.00
Modify  | 0.061919   | 0.061919   | 0.061919   |   0.0 |  0.28
Other   |            | 0.0052     |            |       |  0.02

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

Total # of neighbors = 128236
Ave neighs/atom = 64.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.446625971, Press = 1.48706018527834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8409.0911     -8409.0911     -8492.1822     -8492.1822      321.57138      321.57138      23409.986      23409.986     -390.2902      -390.2902     
     71000  -8412.9287     -8412.9287     -8494.4581     -8494.4581      315.52709      315.52709      23411.286      23411.286     -964.57191     -964.57191    
Loop time of 21.7529 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.972 ns/day, 6.042 hours/ns, 45.971 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    | 21.671     | 21.671     | 21.671     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.07
Output  | 4.0927e-05 | 4.0927e-05 | 4.0927e-05 |   0.0 |  0.00
Modify  | 0.061826   | 0.061826   | 0.061826   |   0.0 |  0.28
Other   |            | 0.005224   |            |       |  0.02

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

Total # of neighbors = 128250
Ave neighs/atom = 64.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456717837891, Press = 1.34126781996613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8412.9287     -8412.9287     -8494.4581     -8494.4581      315.52709      315.52709      23411.286      23411.286     -964.57191     -964.57191    
     72000  -8413.0146     -8413.0146     -8495.7482     -8495.7482      320.18736      320.18736      23405.765      23405.765     -767.68418     -767.68418    
Loop time of 21.8499 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.954 ns/day, 6.069 hours/ns, 45.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    | 21.768     | 21.768     | 21.768     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01485    | 0.01485    | 0.01485    |   0.0 |  0.07
Output  | 2.8784e-05 | 2.8784e-05 | 2.8784e-05 |   0.0 |  0.00
Modify  | 0.061696   | 0.061696   | 0.061696   |   0.0 |  0.28
Other   |            | 0.005183   |            |       |  0.02

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

Total # of neighbors = 128220
Ave neighs/atom = 64.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.420526422896, Press = 1.83264203733806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8413.0146     -8413.0146     -8495.7482     -8495.7482      320.18736      320.18736      23405.765      23405.765     -767.68418     -767.68418    
     73000  -8413.2655     -8413.2655     -8494.485      -8494.485       314.32759      314.32759      23377.542      23377.542      1564.7257      1564.7257    
Loop time of 21.8918 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.947 ns/day, 6.081 hours/ns, 45.679 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    | 21.81      | 21.81      | 21.81      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014915   | 0.014915   | 0.014915   |   0.0 |  0.07
Output  | 2.8563e-05 | 2.8563e-05 | 2.8563e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.28
Other   |            | 0.00518    |            |       |  0.02

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

Total # of neighbors = 128254
Ave neighs/atom = 64.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391897104987, Press = 2.01204675552809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8413.2655     -8413.2655     -8494.485      -8494.485       314.32759      314.32759      23377.542      23377.542      1564.7257      1564.7257    
     74000  -8414.4813     -8414.4813     -8492.5573     -8492.5573      302.16203      302.16203      23356.165      23356.165      3173.6846      3173.6846    
Loop time of 21.8364 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.957 ns/day, 6.066 hours/ns, 45.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    | 21.754     | 21.754     | 21.754     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.07
Output  | 2.8343e-05 | 2.8343e-05 | 2.8343e-05 |   0.0 |  0.00
Modify  | 0.061803   | 0.061803   | 0.061803   |   0.0 |  0.28
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128248
Ave neighs/atom = 64.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.351739103807, Press = 1.64538725457926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8414.4813     -8414.4813     -8492.5573     -8492.5573      302.16203      302.16203      23356.165      23356.165      3173.6846      3173.6846    
     75000  -8413.7701     -8413.7701     -8496.5426     -8496.5426      320.33826      320.33826      23366.326      23366.326      2072.54        2072.54      
Loop time of 21.8043 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.963 ns/day, 6.057 hours/ns, 45.863 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.722     | 21.722     | 21.722     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014873   | 0.014873   | 0.014873   |   0.0 |  0.07
Output  | 2.8283e-05 | 2.8283e-05 | 2.8283e-05 |   0.0 |  0.00
Modify  | 0.061816   | 0.061816   | 0.061816   |   0.0 |  0.28
Other   |            | 0.005181   |            |       |  0.02

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

Total # of neighbors = 128280
Ave neighs/atom = 64.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.326985881304, Press = 0.936139683858397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8413.7701     -8413.7701     -8496.5426     -8496.5426      320.33826      320.33826      23366.326      23366.326      2072.54        2072.54      
     76000  -8409.1468     -8409.1468     -8490.2762     -8490.2762      313.97931      313.97931      23400.153      23400.153      541.74058      541.74058    
Loop time of 21.7469 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.973 ns/day, 6.041 hours/ns, 45.984 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    | 21.665     | 21.665     | 21.665     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.07
Output  | 3.751e-05  | 3.751e-05  | 3.751e-05  |   0.0 |  0.00
Modify  | 0.061823   | 0.061823   | 0.061823   |   0.0 |  0.28
Other   |            | 0.005194   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.326316631047, Press = 0.811981279063767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8409.1468     -8409.1468     -8490.2762     -8490.2762      313.97931      313.97931      23400.153      23400.153      541.74058      541.74058    
     77000  -8414.5142     -8414.5142     -8494.4787     -8494.4787      309.47107      309.47107      23391.197      23391.197      436.79627      436.79627    
Loop time of 21.7573 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.971 ns/day, 6.044 hours/ns, 45.962 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    | 21.675     | 21.675     | 21.675     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014888   | 0.014888   | 0.014888   |   0.0 |  0.07
Output  | 2.8193e-05 | 2.8193e-05 | 2.8193e-05 |   0.0 |  0.00
Modify  | 0.061791   | 0.061791   | 0.061791   |   0.0 |  0.28
Other   |            | 0.005199   |            |       |  0.02

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

Total # of neighbors = 128230
Ave neighs/atom = 64.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.345274183102, Press = 1.1291168753324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8414.5142     -8414.5142     -8494.4787     -8494.4787      309.47107      309.47107      23391.197      23391.197      436.79627      436.79627    
     78000  -8407.8249     -8407.8249     -8491.7213     -8491.7213      324.68755      324.68755      23414.358      23414.358     -628.37383     -628.37383    
Loop time of 21.7011 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.981 ns/day, 6.028 hours/ns, 46.081 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    | 21.619     | 21.619     | 21.619     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014868   | 0.014868   | 0.014868   |   0.0 |  0.07
Output  | 2.9135e-05 | 2.9135e-05 | 2.9135e-05 |   0.0 |  0.00
Modify  | 0.061748   | 0.061748   | 0.061748   |   0.0 |  0.28
Other   |            | 0.005179   |            |       |  0.02

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

Total # of neighbors = 128244
Ave neighs/atom = 64.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.377526605502, Press = 1.04941739544031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -8407.8249     -8407.8249     -8491.7213     -8491.7213      324.68755      324.68755      23414.358      23414.358     -628.37383     -628.37383    
     79000  -8415.1272     -8415.1272     -8495.1277     -8495.1277      309.60992      309.60992      23418.984      23418.984     -1762.2443     -1762.2443    
Loop time of 21.865 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.074 hours/ns, 45.735 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    | 21.783     | 21.783     | 21.783     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014872   | 0.014872   | 0.014872   |   0.0 |  0.07
Output  | 3.702e-05  | 3.702e-05  | 3.702e-05  |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.28
Other   |            | 0.005208   |            |       |  0.02

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

Total # of neighbors = 128272
Ave neighs/atom = 64.136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393885978834, Press = 0.858106797629943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -8415.1272     -8415.1272     -8495.1277     -8495.1277      309.60992      309.60992      23418.984      23418.984     -1762.2443     -1762.2443    
     80000  -8413.5463     -8413.5463     -8493.9195     -8493.9195      311.0525       311.0525       23439.553      23439.553     -2896.3574     -2896.3574    
Loop time of 21.6891 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.025 hours/ns, 46.106 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    | 21.607     | 21.607     | 21.607     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.07
Output  | 2.8544e-05 | 2.8544e-05 | 2.8544e-05 |   0.0 |  0.00
Modify  | 0.061785   | 0.061785   | 0.061785   |   0.0 |  0.28
Other   |            | 0.005243   |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.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 = 313.409062148937, Press = 1.45723297136905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -8413.5463     -8413.5463     -8493.9195     -8493.9195      311.0525       311.0525       23439.553      23439.553     -2896.3574     -2896.3574    
     81000  -8409.5575     -8409.5575     -8491.2695     -8491.2695      316.23383      316.23383      23423.615      23423.615     -1313.3771     -1313.3771    
Loop time of 21.6239 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.996 ns/day, 6.007 hours/ns, 46.245 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    | 21.542     | 21.542     | 21.542     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.07
Output  | 2.8313e-05 | 2.8313e-05 | 2.8313e-05 |   0.0 |  0.00
Modify  | 0.061751   | 0.061751   | 0.061751   |   0.0 |  0.29
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128204
Ave neighs/atom = 64.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425075643941, Press = 1.97649238481826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -8409.5575     -8409.5575     -8491.2695     -8491.2695      316.23383      316.23383      23423.615      23423.615     -1313.3771     -1313.3771    
     82000  -8414.7389     -8414.7389     -8494.9733     -8494.9733      310.51543      310.51543      23379.074      23379.074      1213.0544      1213.0544    
Loop time of 21.6966 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.982 ns/day, 6.027 hours/ns, 46.090 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    | 21.615     | 21.615     | 21.615     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.07
Output  | 3.719e-05  | 3.719e-05  | 3.719e-05  |   0.0 |  0.00
Modify  | 0.061762   | 0.061762   | 0.061762   |   0.0 |  0.28
Other   |            | 0.005216   |            |       |  0.02

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

Total # of neighbors = 128254
Ave neighs/atom = 64.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.454577036687, Press = 1.8482670635441
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -8414.7389     -8414.7389     -8494.9733     -8494.9733      310.51543      310.51543      23379.074      23379.074      1213.0544      1213.0544    
     83000  -8408.7887     -8408.7887     -8491.5564     -8491.5564      320.31949      320.31949      23390.814      23390.814      1121.9137      1121.9137    
Loop time of 21.6277 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.008 hours/ns, 46.237 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    | 21.546     | 21.546     | 21.546     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01493    | 0.01493    | 0.01493    |   0.0 |  0.07
Output  | 2.9204e-05 | 2.9204e-05 | 2.9204e-05 |   0.0 |  0.00
Modify  | 0.06176    | 0.06176    | 0.06176    |   0.0 |  0.29
Other   |            | 0.005192   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469885024905, Press = 1.21249268918674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -8408.7887     -8408.7887     -8491.5564     -8491.5564      320.31949      320.31949      23390.814      23390.814      1121.9137      1121.9137    
     84000  -8414.0565     -8414.0565     -8494.7998     -8494.7998      312.48486      312.48486      23387.95       23387.95       639.94095      639.94095    
Loop time of 21.7434 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.974 ns/day, 6.040 hours/ns, 45.991 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    | 21.661     | 21.661     | 21.661     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014859   | 0.014859   | 0.014859   |   0.0 |  0.07
Output  | 3.6448e-05 | 3.6448e-05 | 3.6448e-05 |   0.0 |  0.00
Modify  | 0.061828   | 0.061828   | 0.061828   |   0.0 |  0.28
Other   |            | 0.005197   |            |       |  0.02

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

Total # of neighbors = 128240
Ave neighs/atom = 64.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.464393754984, Press = 0.916927032224729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -8414.0565     -8414.0565     -8494.7998     -8494.7998      312.48486      312.48486      23387.95       23387.95       639.94095      639.94095    
     85000  -8413.5547     -8413.5547     -8493.9372     -8493.9372      311.08865      311.08865      23390.671      23390.671      477.91644      477.91644    
Loop time of 21.7896 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.893 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    | 21.708     | 21.708     | 21.708     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01491    | 0.01491    | 0.01491    |   0.0 |  0.07
Output  | 2.8694e-05 | 2.8694e-05 | 2.8694e-05 |   0.0 |  0.00
Modify  | 0.061727   | 0.061727   | 0.061727   |   0.0 |  0.28
Other   |            | 0.005191   |            |       |  0.02

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

Total # of neighbors = 128256
Ave neighs/atom = 64.128
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.443787018211, Press = 1.1298975757419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -8413.5547     -8413.5547     -8493.9372     -8493.9372      311.08865      311.08865      23390.671      23390.671      477.91644      477.91644    
     86000  -8414.2902     -8414.2902     -8494.2355     -8494.2355      309.39648      309.39648      23379.297      23379.297      1213.3822      1213.3822    
Loop time of 21.7667 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.969 ns/day, 6.046 hours/ns, 45.942 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    | 21.685     | 21.685     | 21.685     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.07
Output  | 2.7832e-05 | 2.7832e-05 | 2.7832e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.28
Other   |            | 0.005188   |            |       |  0.02

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

Total # of neighbors = 128232
Ave neighs/atom = 64.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40512811145, Press = 0.948780405771357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -8414.2902     -8414.2902     -8494.2355     -8494.2355      309.39648      309.39648      23379.297      23379.297      1213.3822      1213.3822    
     87000  -8417.6388     -8417.6388     -8497.3964     -8497.3964      308.6702       308.6702       23375.493      23375.493      1020.7746      1020.7746    
Loop time of 21.6876 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.024 hours/ns, 46.109 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    | 21.606     | 21.606     | 21.606     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014957   | 0.014957   | 0.014957   |   0.0 |  0.07
Output  | 3.7851e-05 | 3.7851e-05 | 3.7851e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.28
Other   |            | 0.005175   |            |       |  0.02

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

Total # of neighbors = 128330
Ave neighs/atom = 64.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.392789252204, Press = 0.251459704707807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -8417.6388     -8417.6388     -8497.3964     -8497.3964      308.6702       308.6702       23375.493      23375.493      1020.7746      1020.7746    
     88000  -8413.9406     -8413.9406     -8495.8717     -8495.8717      317.08197      317.08197      23414.001      23414.001     -1454.1974     -1454.1974    
Loop time of 21.6893 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.984 ns/day, 6.025 hours/ns, 46.106 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    | 21.607     | 21.607     | 21.607     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.07
Output  | 2.8584e-05 | 2.8584e-05 | 2.8584e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.28
Other   |            | 0.005189   |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.353857835721, Press = -0.0308060903280957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -8413.9406     -8413.9406     -8495.8717     -8495.8717      317.08197      317.08197      23414.001      23414.001     -1454.1974     -1454.1974    
     89000  -8414.1673     -8414.1673     -8493.9762     -8493.9762      308.86859      308.86859      23430.941      23430.941     -2380.2058     -2380.2058    
Loop time of 21.6965 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.982 ns/day, 6.027 hours/ns, 46.090 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    | 21.615     | 21.615     | 21.615     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014945   | 0.014945   | 0.014945   |   0.0 |  0.07
Output  | 2.8564e-05 | 2.8564e-05 | 2.8564e-05 |   0.0 |  0.00
Modify  | 0.061623   | 0.061623   | 0.061623   |   0.0 |  0.28
Other   |            | 0.005191   |            |       |  0.02

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

Total # of neighbors = 128194
Ave neighs/atom = 64.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358277072104, Press = 0.330352899636354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -8414.1673     -8414.1673     -8493.9762     -8493.9762      308.86859      308.86859      23430.941      23430.941     -2380.2058     -2380.2058    
     90000  -8415.3385     -8415.3385     -8495.8138     -8495.8138      311.44742      311.44742      23416.788      23416.788     -1599.0691     -1599.0691    
Loop time of 21.7056 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.981 ns/day, 6.029 hours/ns, 46.071 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    | 21.624     | 21.624     | 21.624     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01493    | 0.01493    | 0.01493    |   0.0 |  0.07
Output  | 3.5887e-05 | 3.5887e-05 | 3.5887e-05 |   0.0 |  0.00
Modify  | 0.061761   | 0.061761   | 0.061761   |   0.0 |  0.28
Other   |            | 0.005214   |            |       |  0.02

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

Total # of neighbors = 128206
Ave neighs/atom = 64.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.377150235693, Press = 0.849350052081561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -8415.3385     -8415.3385     -8495.8138     -8495.8138      311.44742      311.44742      23416.788      23416.788     -1599.0691     -1599.0691    
     91000  -8415.4879     -8415.4879     -8494.8597     -8494.8597      307.17719      307.17719      23407.028      23407.028     -930.4888      -930.4888     
Loop time of 21.7651 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.970 ns/day, 6.046 hours/ns, 45.945 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    | 21.683     | 21.683     | 21.683     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014874   | 0.014874   | 0.014874   |   0.0 |  0.07
Output  | 2.8804e-05 | 2.8804e-05 | 2.8804e-05 |   0.0 |  0.00
Modify  | 0.06171    | 0.06171    | 0.06171    |   0.0 |  0.28
Other   |            | 0.00519    |            |       |  0.02

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

Total # of neighbors = 128234
Ave neighs/atom = 64.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.379696608743, Press = 1.14275243433938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -8415.4879     -8415.4879     -8494.8597     -8494.8597      307.17719      307.17719      23407.028      23407.028     -930.4888      -930.4888     
     92000  -8413.2904     -8413.2904     -8493.9531     -8493.9531      312.17319      312.17319      23401.224      23401.224     -178.78479     -178.78479    
Loop time of 21.6337 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.994 ns/day, 6.009 hours/ns, 46.224 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    | 21.552     | 21.552     | 21.552     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014947   | 0.014947   | 0.014947   |   0.0 |  0.07
Output  | 2.7913e-05 | 2.7913e-05 | 2.7913e-05 |   0.0 |  0.00
Modify  | 0.061614   | 0.061614   | 0.061614   |   0.0 |  0.28
Other   |            | 0.005191   |            |       |  0.02

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

Total # of neighbors = 128236
Ave neighs/atom = 64.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.373368304486, Press = 1.36159516928419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -8413.2904     -8413.2904     -8493.9531     -8493.9531      312.17319      312.17319      23401.224      23401.224     -178.78479     -178.78479    
     93000  -8418.2962     -8418.2962     -8498.5876     -8498.5876      310.73586      310.73586      23350.805      23350.805      2695.7243      2695.7243    
Loop time of 21.7371 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.975 ns/day, 6.038 hours/ns, 46.004 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    | 21.655     | 21.655     | 21.655     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014874   | 0.014874   | 0.014874   |   0.0 |  0.07
Output  | 3.6518e-05 | 3.6518e-05 | 3.6518e-05 |   0.0 |  0.00
Modify  | 0.061784   | 0.061784   | 0.061784   |   0.0 |  0.28
Other   |            | 0.005208   |            |       |  0.02

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

Total # of neighbors = 128260
Ave neighs/atom = 64.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38160013655, Press = 1.74883333057254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -8418.2962     -8418.2962     -8498.5876     -8498.5876      310.73586      310.73586      23350.805      23350.805      2695.7243      2695.7243    
     94000  -8413.0711     -8413.0711     -8494.506      -8494.506       315.1614       315.1614       23336.036      23336.036      4515.3073      4515.3073    
Loop time of 21.6949 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.983 ns/day, 6.026 hours/ns, 46.094 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    | 21.613     | 21.613     | 21.613     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014875   | 0.014875   | 0.014875   |   0.0 |  0.07
Output  | 2.8544e-05 | 2.8544e-05 | 2.8544e-05 |   0.0 |  0.00
Modify  | 0.061684   | 0.061684   | 0.061684   |   0.0 |  0.28
Other   |            | 0.005191   |            |       |  0.02

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

Total # of neighbors = 128240
Ave neighs/atom = 64.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358884176942, Press = 0.908372818318053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -8413.0711     -8413.0711     -8494.506      -8494.506       315.1614       315.1614       23336.036      23336.036      4515.3073      4515.3073    
     95000  -8413.5279     -8413.5279     -8493.1163     -8493.1163      308.01525      308.01525      23375.29       23375.29       1820.8848      1820.8848    
Loop time of 21.721 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.034 hours/ns, 46.038 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    | 21.639     | 21.639     | 21.639     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.07
Output  | 3.5416e-05 | 3.5416e-05 | 3.5416e-05 |   0.0 |  0.00
Modify  | 0.061673   | 0.061673   | 0.061673   |   0.0 |  0.28
Other   |            | 0.005191   |            |       |  0.02

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

Total # of neighbors = 128316
Ave neighs/atom = 64.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.385024877209, Press = 0.414090721379421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -8413.5279     -8413.5279     -8493.1163     -8493.1163      308.01525      308.01525      23375.29       23375.29       1820.8848      1820.8848    
     96000  -8418.6544     -8418.6544     -8495.751      -8495.751       298.37183      298.37183      23396.209      23396.209     -338.78874     -338.78874    
Loop time of 21.6444 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.992 ns/day, 6.012 hours/ns, 46.201 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    | 21.563     | 21.563     | 21.563     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014886   | 0.014886   | 0.014886   |   0.0 |  0.07
Output  | 3.0607e-05 | 3.0607e-05 | 3.0607e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.29
Other   |            | 0.005171   |            |       |  0.02

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

Total # of neighbors = 128268
Ave neighs/atom = 64.134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.366782196476, Press = 0.516769091266713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -8418.6544     -8418.6544     -8495.751      -8495.751       298.37183      298.37183      23396.209      23396.209     -338.78874     -338.78874    
     97000  -8413.3733     -8413.3733     -8494.9038     -8494.9038      315.5312       315.5312       23416.567      23416.567     -1438.8229     -1438.8229    
Loop time of 21.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.022 hours/ns, 46.125 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    | 21.598     | 21.598     | 21.598     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014832   | 0.014832   | 0.014832   |   0.0 |  0.07
Output  | 5.9512e-05 | 5.9512e-05 | 5.9512e-05 |   0.0 |  0.00
Modify  | 0.061761   | 0.061761   | 0.061761   |   0.0 |  0.28
Other   |            | 0.005172   |            |       |  0.02

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

Total # of neighbors = 128232
Ave neighs/atom = 64.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361244659681, Press = 0.808098377960825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -8413.3733     -8413.3733     -8494.9038     -8494.9038      315.5312       315.5312       23416.567      23416.567     -1438.8229     -1438.8229    
     98000  -8413.3563     -8413.3563     -8494.5969     -8494.5969      314.40918      314.40918      23442.961      23442.961     -3381.3658     -3381.3658    
Loop time of 21.7198 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.033 hours/ns, 46.041 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    | 21.638     | 21.638     | 21.638     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.07
Output  | 3.7942e-05 | 3.7942e-05 | 3.7942e-05 |   0.0 |  0.00
Modify  | 0.061831   | 0.061831   | 0.061831   |   0.0 |  0.28
Other   |            | 0.005194   |            |       |  0.02

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

Total # of neighbors = 128232
Ave neighs/atom = 64.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.354800812405, Press = 1.145594139761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -8413.3563     -8413.3563     -8494.5969     -8494.5969      314.40918      314.40918      23442.961      23442.961     -3381.3658     -3381.3658    
     99000  -8414.3284     -8414.3284     -8495.2148     -8495.2148      313.03896      313.03896      23429.758      23429.758     -2440.6776     -2440.6776    
Loop time of 21.7558 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.971 ns/day, 6.043 hours/ns, 45.965 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    | 21.674     | 21.674     | 21.674     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014942   | 0.014942   | 0.014942   |   0.0 |  0.07
Output  | 2.8143e-05 | 2.8143e-05 | 2.8143e-05 |   0.0 |  0.00
Modify  | 0.061709   | 0.061709   | 0.061709   |   0.0 |  0.28
Other   |            | 0.005196   |            |       |  0.02

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

Total # of neighbors = 128212
Ave neighs/atom = 64.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.34253920351, Press = 1.99663040715869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -8414.3284     -8414.3284     -8495.2148     -8495.2148      313.03896      313.03896      23429.758      23429.758     -2440.6776     -2440.6776    
    100000  -8413.3733     -8413.3733     -8494.0155     -8494.0155      312.09359      312.09359      23395.646      23395.646      212.33742      212.33742    
Loop time of 21.8162 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.960 ns/day, 6.060 hours/ns, 45.837 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    | 21.734     | 21.734     | 21.734     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014909   | 0.014909   | 0.014909   |   0.0 |  0.07
Output  | 2.8714e-05 | 2.8714e-05 | 2.8714e-05 |   0.0 |  0.00
Modify  | 0.061848   | 0.061848   | 0.061848   |   0.0 |  0.28
Other   |            | 0.005201   |            |       |  0.02

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

Total # of neighbors = 128234
Ave neighs/atom = 64.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.327630209774, Press = 1.57127254971745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -8413.3733     -8413.3733     -8494.0155     -8494.0155      312.09359      312.09359      23395.646      23395.646      212.33742      212.33742    
    101000  -8413.1366     -8413.1366     -8495.7805     -8495.7805      319.84048      319.84048      23382.35       23382.35       979.97427      979.97427    
Loop time of 21.8415 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.956 ns/day, 6.067 hours/ns, 45.784 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    | 21.76      | 21.76      | 21.76      |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.07
Output  | 3.6498e-05 | 3.6498e-05 | 3.6498e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.28
Other   |            | 0.005198   |            |       |  0.02

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

Total # of neighbors = 128266
Ave neighs/atom = 64.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.345952755856, Press = 1.24340453399797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -8413.1366     -8413.1366     -8495.7805     -8495.7805      319.84048      319.84048      23382.35       23382.35       979.97427      979.97427    
    102000  -8411.6596     -8411.6596     -8493.7271     -8493.7271      317.60971      317.60971      23374.731      23374.731      1811.2996      1811.2996    
Loop time of 21.8181 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.960 ns/day, 6.061 hours/ns, 45.833 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.736     | 21.736     | 21.736     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.07
Output  | 2.8173e-05 | 2.8173e-05 | 2.8173e-05 |   0.0 |  0.00
Modify  | 0.061932   | 0.061932   | 0.061932   |   0.0 |  0.28
Other   |            | 0.005209   |            |       |  0.02

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

Total # of neighbors = 128186
Ave neighs/atom = 64.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358443548463, Press = 0.88149458965048
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -8411.6596     -8411.6596     -8493.7271     -8493.7271      317.60971      317.60971      23374.731      23374.731      1811.2996      1811.2996    
    103000  -8414.8078     -8414.8078     -8494.149      -8494.149       307.05889      307.05889      23361.82       23361.82       2531.6943      2531.6943    
Loop time of 21.6943 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.983 ns/day, 6.026 hours/ns, 46.095 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    | 21.612     | 21.612     | 21.612     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014876   | 0.014876   | 0.014876   |   0.0 |  0.07
Output  | 2.7983e-05 | 2.7983e-05 | 2.7983e-05 |   0.0 |  0.00
Modify  | 0.061862   | 0.061862   | 0.061862   |   0.0 |  0.29
Other   |            | 0.005176   |            |       |  0.02

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

Total # of neighbors = 128254
Ave neighs/atom = 64.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383386076847, Press = 0.245722897978625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -8414.8078     -8414.8078     -8494.149      -8494.149       307.05889      307.05889      23361.82       23361.82       2531.6943      2531.6943    
    104000  -8415.8368     -8415.8368     -8495.7287     -8495.7287      309.19011      309.19011      23393.188      23393.188      63.900449      63.900449    
Loop time of 21.7261 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.035 hours/ns, 46.028 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    | 21.644     | 21.644     | 21.644     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015013   | 0.015013   | 0.015013   |   0.0 |  0.07
Output  | 3.8202e-05 | 3.8202e-05 | 3.8202e-05 |   0.0 |  0.00
Modify  | 0.061805   | 0.061805   | 0.061805   |   0.0 |  0.28
Other   |            | 0.005196   |            |       |  0.02

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

Total # of neighbors = 128260
Ave neighs/atom = 64.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.403397587705, Press = -0.147101389683331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -8415.8368     -8415.8368     -8495.7287     -8495.7287      309.19011      309.19011      23393.188      23393.188      63.900449      63.900449    
    105000  -8415.9929     -8415.9929     -8495.1911     -8495.1911      306.50542      306.50542      23407.426      23407.426     -856.50571     -856.50571    
Loop time of 21.6835 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.023 hours/ns, 46.118 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    | 21.602     | 21.602     | 21.602     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.07
Output  | 2.8253e-05 | 2.8253e-05 | 2.8253e-05 |   0.0 |  0.00
Modify  | 0.061713   | 0.061713   | 0.061713   |   0.0 |  0.28
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128224
Ave neighs/atom = 64.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 = 313.412594181988, Press = 0.671790354560842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -8415.9929     -8415.9929     -8495.1911     -8495.1911      306.50542      306.50542      23407.426      23407.426     -856.50571     -856.50571    
    106000  -8417.7321     -8417.7321     -8497.8849     -8497.8849      310.19975      310.19975      23408.772      23408.772     -1317.6212     -1317.6212    
Loop time of 21.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.985 ns/day, 6.022 hours/ns, 46.125 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    | 21.598     | 21.598     | 21.598     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014886   | 0.014886   | 0.014886   |   0.0 |  0.07
Output  | 3.3463e-05 | 3.3463e-05 | 3.3463e-05 |   0.0 |  0.00
Modify  | 0.061722   | 0.061722   | 0.061722   |   0.0 |  0.28
Other   |            | 0.005178   |            |       |  0.02

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

Total # of neighbors = 128216
Ave neighs/atom = 64.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.395483801189, Press = 0.986872516630223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -8417.7321     -8417.7321     -8497.8849     -8497.8849      310.19975      310.19975      23408.772      23408.772     -1317.6212     -1317.6212    
    107000  -8414.0703     -8414.0703     -8494.2903     -8494.2903      310.4599       310.4599       23391.776      23391.776      444.90836      444.90836    
Loop time of 21.7792 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.967 ns/day, 6.050 hours/ns, 45.915 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    | 21.697     | 21.697     | 21.697     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.07
Output  | 2.8814e-05 | 2.8814e-05 | 2.8814e-05 |   0.0 |  0.00
Modify  | 0.061843   | 0.061843   | 0.061843   |   0.0 |  0.28
Other   |            | 0.005213   |            |       |  0.02

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

Total # of neighbors = 128226
Ave neighs/atom = 64.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.379511366588, Press = 1.32787810208577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -8414.0703     -8414.0703     -8494.2903     -8494.2903      310.4599       310.4599       23391.776      23391.776      444.90836      444.90836    
    108000  -8411.3168     -8411.3168     -8493.4095     -8493.4095      317.70744      317.70744      23356.702      23356.702      3185.7593      3185.7593    
Loop time of 21.7733 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.968 ns/day, 6.048 hours/ns, 45.928 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    | 21.692     | 21.692     | 21.692     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.07
Output  | 2.9555e-05 | 2.9555e-05 | 2.9555e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.28
Other   |            | 0.005182   |            |       |  0.02

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

Total # of neighbors = 128210
Ave neighs/atom = 64.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.366451264255, Press = 1.35523017099626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -8411.3168     -8411.3168     -8493.4095     -8493.4095      317.70744      317.70744      23356.702      23356.702      3185.7593      3185.7593    
    109000  -8414.3        -8414.3        -8494.1049     -8494.1049      308.8532       308.8532       23329.242      23329.242      4921.3284      4921.3284    
Loop time of 21.8476 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.955 ns/day, 6.069 hours/ns, 45.772 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    | 21.766     | 21.766     | 21.766     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.07
Output  | 3.6498e-05 | 3.6498e-05 | 3.6498e-05 |   0.0 |  0.00
Modify  | 0.061786   | 0.061786   | 0.061786   |   0.0 |  0.28
Other   |            | 0.005192   |            |       |  0.02

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

Total # of neighbors = 128304
Ave neighs/atom = 64.152
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.37071620222, Press = 0.662857461679875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -8414.3        -8414.3        -8494.1049     -8494.1049      308.8532       308.8532       23329.242      23329.242      4921.3284      4921.3284    
    110000  -8410.7122     -8410.7122     -8493.3185     -8493.3185      319.69484      319.69484      23384.344      23384.344      1223.917       1223.917     
Loop time of 21.7244 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.035 hours/ns, 46.031 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    | 21.643     | 21.643     | 21.643     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.07
Output  | 3.2361e-05 | 3.2361e-05 | 3.2361e-05 |   0.0 |  0.00
Modify  | 0.061703   | 0.061703   | 0.061703   |   0.0 |  0.28
Other   |            | 0.005183   |            |       |  0.02

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

Total # of neighbors = 128330
Ave neighs/atom = 64.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.392660530691, Press = 0.534494192162691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -8410.7122     -8410.7122     -8493.3185     -8493.3185      319.69484      319.69484      23384.344      23384.344      1223.917       1223.917     
    111000  -8414.6858     -8414.6858     -8495.0507     -8495.0507      311.0203       311.0203       23402.541      23402.541     -565.17891     -565.17891    
Loop time of 21.7097 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.030 hours/ns, 46.062 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    | 21.628     | 21.628     | 21.628     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01487    | 0.01487    | 0.01487    |   0.0 |  0.07
Output  | 3.0086e-05 | 3.0086e-05 | 3.0086e-05 |   0.0 |  0.00
Modify  | 0.061655   | 0.061655   | 0.061655   |   0.0 |  0.28
Other   |            | 0.00518    |            |       |  0.02

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

Total # of neighbors = 128284
Ave neighs/atom = 64.142
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.411540770871, Press = 0.524280383105814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -8414.6858     -8414.6858     -8495.0507     -8495.0507      311.0203       311.0203       23402.541      23402.541     -565.17891     -565.17891    
    112000  -8411.0982     -8411.0982     -8493.9038     -8493.9038      320.46638      320.46638      23420.806      23420.806     -1451.1538     -1451.1538    
Loop time of 21.7046 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.981 ns/day, 6.029 hours/ns, 46.073 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    | 21.623     | 21.623     | 21.623     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.07
Output  | 3.6769e-05 | 3.6769e-05 | 3.6769e-05 |   0.0 |  0.00
Modify  | 0.061784   | 0.061784   | 0.061784   |   0.0 |  0.28
Other   |            | 0.00519    |            |       |  0.02

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

Total # of neighbors = 128222
Ave neighs/atom = 64.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415407563861, Press = 0.834315282819364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -8411.0982     -8411.0982     -8493.9038     -8493.9038      320.46638      320.46638      23420.806      23420.806     -1451.1538     -1451.1538    
    113000  -8414.4089     -8414.4089     -8495.3164     -8495.3164      313.12012      313.12012      23415.99       23415.99      -1465.4055     -1465.4055    
Loop time of 21.7218 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.034 hours/ns, 46.037 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    | 21.64      | 21.64      | 21.64      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.07
Output  | 2.2091e-05 | 2.2091e-05 | 2.2091e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.28
Other   |            | 0.005166   |            |       |  0.02

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

Total # of neighbors = 128274
Ave neighs/atom = 64.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40515137651, Press = 1.38975144427382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -8414.4089     -8414.4089     -8495.3164     -8495.3164      313.12012      313.12012      23415.99       23415.99      -1465.4055     -1465.4055    
    114000  -8416.4719     -8416.4719     -8495.2183     -8495.2183      304.75677      304.75677      23375.159      23375.159      1421.543       1421.543     
Loop time of 21.6984 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.982 ns/day, 6.027 hours/ns, 46.086 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    | 21.617     | 21.617     | 21.617     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014861   | 0.014861   | 0.014861   |   0.0 |  0.07
Output  | 2.1771e-05 | 2.1771e-05 | 2.1771e-05 |   0.0 |  0.00
Modify  | 0.061546   | 0.061546   | 0.061546   |   0.0 |  0.28
Other   |            | 0.005183   |            |       |  0.02

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

Total # of neighbors = 128270
Ave neighs/atom = 64.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392619121231, Press = 1.93357348570799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -8416.4719     -8416.4719     -8495.2183     -8495.2183      304.75677      304.75677      23375.159      23375.159      1421.543       1421.543     
    115000  -8415.0635     -8415.0635     -8494.4842     -8494.4842      307.36602      307.36602      23353.197      23353.197      3185.8517      3185.8517    
Loop time of 21.7902 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.892 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    | 21.708     | 21.708     | 21.708     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014894   | 0.014894   | 0.014894   |   0.0 |  0.07
Output  | 3.0367e-05 | 3.0367e-05 | 3.0367e-05 |   0.0 |  0.00
Modify  | 0.061733   | 0.061733   | 0.061733   |   0.0 |  0.28
Other   |            | 0.005178   |            |       |  0.02

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

Total # of neighbors = 128270
Ave neighs/atom = 64.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.359652516133, Press = 1.46913923731953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -8415.0635     -8415.0635     -8494.4842     -8494.4842      307.36602      307.36602      23353.197      23353.197      3185.8517      3185.8517    
    116000  -8414.1255     -8414.1255     -8495.8539     -8495.8539      316.29739      316.29739      23365.79       23365.79       2156.3499      2156.3499    
Loop time of 21.7902 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.892 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    | 21.708     | 21.708     | 21.708     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014853   | 0.014853   | 0.014853   |   0.0 |  0.07
Output  | 2.4927e-05 | 2.4927e-05 | 2.4927e-05 |   0.0 |  0.00
Modify  | 0.061849   | 0.061849   | 0.061849   |   0.0 |  0.28
Other   |            | 0.005189   |            |       |  0.02

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

Total # of neighbors = 128306
Ave neighs/atom = 64.153
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361427607717, Press = 0.764887302722453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -8414.1255     -8414.1255     -8495.8539     -8495.8539      316.29739      316.29739      23365.79       23365.79       2156.3499      2156.3499    
    117000  -8417.3879     -8417.3879     -8495.2992     -8495.2992      301.52496      301.52496      23383.661      23383.661      792.12916      792.12916    
Loop time of 21.7235 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.977 ns/day, 6.034 hours/ns, 46.033 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    | 21.642     | 21.642     | 21.642     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014855   | 0.014855   | 0.014855   |   0.0 |  0.07
Output  | 2.7482e-05 | 2.7482e-05 | 2.7482e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.28
Other   |            | 0.005204   |            |       |  0.02

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

Total # of neighbors = 128242
Ave neighs/atom = 64.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.330803956497, Press = 0.554078821902607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -8417.3879     -8417.3879     -8495.2992     -8495.2992      301.52496      301.52496      23383.661      23383.661      792.12916      792.12916    
    118000  -8412.5143     -8412.5143     -8495.8498     -8495.8498      322.51724      322.51724      23408.79       23408.79      -836.90823     -836.90823    
Loop time of 21.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.967 ns/day, 6.050 hours/ns, 45.914 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    | 21.698     | 21.698     | 21.698     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014906   | 0.014906   | 0.014906   |   0.0 |  0.07
Output  | 2.141e-05  | 2.141e-05  | 2.141e-05  |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.28
Other   |            | 0.005187   |            |       |  0.02

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

Total # of neighbors = 128202
Ave neighs/atom = 64.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.329247521234, Press = 0.558142077000195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -8412.5143     -8412.5143     -8495.8498     -8495.8498      322.51724      322.51724      23408.79       23408.79      -836.90823     -836.90823    
    119000  -8413.9967     -8413.9967     -8496.1368     -8496.1368      317.89083      317.89083      23455.834      23455.834     -4432.8292     -4432.8292    
Loop time of 21.7304 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.036 hours/ns, 46.019 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    | 21.648     | 21.648     | 21.648     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.07
Output  | 2.1681e-05 | 2.1681e-05 | 2.1681e-05 |   0.0 |  0.00
Modify  | 0.061801   | 0.061801   | 0.061801   |   0.0 |  0.28
Other   |            | 0.005176   |            |       |  0.02

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

Total # of neighbors = 128196
Ave neighs/atom = 64.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.333133451058, Press = 0.453633188728528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -8413.9967     -8413.9967     -8496.1368     -8496.1368      317.89083      317.89083      23455.834      23455.834     -4432.8292     -4432.8292    
    120000  -8412.5429     -8412.5429     -8493.1025     -8493.1025      311.77407      311.77407      23448.278      23448.278     -3475.3151     -3475.3151    
Loop time of 21.7293 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.036 hours/ns, 46.021 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    | 21.648     | 21.648     | 21.648     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014875   | 0.014875   | 0.014875   |   0.0 |  0.07
Output  | 3.0016e-05 | 3.0016e-05 | 3.0016e-05 |   0.0 |  0.00
Modify  | 0.06173    | 0.06173    | 0.06173    |   0.0 |  0.28
Other   |            | 0.005195   |            |       |  0.02

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

Total # of neighbors = 128180
Ave neighs/atom = 64.09
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.329654889579, Press = 1.24222834260241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -8412.5429     -8412.5429     -8493.1025     -8493.1025      311.77407      311.77407      23448.278      23448.278     -3475.3151     -3475.3151    
    121000  -8412.6554     -8412.6554     -8493.8117     -8493.8117      314.08314      314.08314      23408.857      23408.857     -745.16392     -745.16392    
Loop time of 21.7456 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.973 ns/day, 6.040 hours/ns, 45.986 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    | 21.664     | 21.664     | 21.664     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.07
Output  | 2.16e-05   | 2.16e-05   | 2.16e-05   |   0.0 |  0.00
Modify  | 0.061769   | 0.061769   | 0.061769   |   0.0 |  0.28
Other   |            | 0.0052     |            |       |  0.02

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

Total # of neighbors = 128236
Ave neighs/atom = 64.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.331623543245, Press = 1.4151111055196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -8412.6554     -8412.6554     -8493.8117     -8493.8117      314.08314      314.08314      23408.857      23408.857     -745.16392     -745.16392    
    122000  -8411.1278     -8411.1278     -8493.4657     -8493.4657      318.65598      318.65598      23386.98       23386.98       1000.3338      1000.3338    
Loop time of 21.7362 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.975 ns/day, 6.038 hours/ns, 46.006 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    | 21.654     | 21.654     | 21.654     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.07
Output  | 2.2251e-05 | 2.2251e-05 | 2.2251e-05 |   0.0 |  0.00
Modify  | 0.061814   | 0.061814   | 0.061814   |   0.0 |  0.28
Other   |            | 0.005185   |            |       |  0.02

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

Total # of neighbors = 128258
Ave neighs/atom = 64.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.338628420858, Press = 1.22979012318138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -8411.1278     -8411.1278     -8493.4657     -8493.4657      318.65598      318.65598      23386.98       23386.98       1000.3338      1000.3338    
    123000  -8416.2823     -8416.2823     -8496.9233     -8496.9233      312.08906      312.08906      23373.199      23373.199      1452.9942      1452.9942    
Loop time of 21.7932 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.054 hours/ns, 45.886 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    | 21.711     | 21.711     | 21.711     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014909   | 0.014909   | 0.014909   |   0.0 |  0.07
Output  | 2.9736e-05 | 2.9736e-05 | 2.9736e-05 |   0.0 |  0.00
Modify  | 0.061733   | 0.061733   | 0.061733   |   0.0 |  0.28
Other   |            | 0.005201   |            |       |  0.02

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

Total # of neighbors = 128274
Ave neighs/atom = 64.137
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.320238204927, Press = 0.852051559036466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -8416.2823     -8416.2823     -8496.9233     -8496.9233      312.08906      312.08906      23373.199      23373.199      1452.9942      1452.9942    
    124000  -8415.0214     -8415.0214     -8496.0793     -8496.0793      313.7025       313.7025       23371.602      23371.602      1618.7098      1618.7098    
Loop time of 21.8548 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.953 ns/day, 6.071 hours/ns, 45.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    | 21.773     | 21.773     | 21.773     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014944   | 0.014944   | 0.014944   |   0.0 |  0.07
Output  | 2.2302e-05 | 2.2302e-05 | 2.2302e-05 |   0.0 |  0.00
Modify  | 0.061865   | 0.061865   | 0.061865   |   0.0 |  0.28
Other   |            | 0.005201   |            |       |  0.02

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0