# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.5670029968023296*${_u_distance}
variable latticeconst_converted equal 3.5670029968023296*1
lattice       diamond  ${latticeconst_converted}
lattice       diamond  3.56700299680233
Lattice spacing in x,y,z = 3.567003 3.567003 3.567003
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.67003 35.67003 35.67003)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 8000 atoms
  using lattice units in orthogonal box = (0 0 0) to (35.67003 35.67003 35.67003)
  create_atoms CPU = 0.007 seconds

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

kim_interactions C

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

kim interactions C
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_AslamBaskesDickel_2019_FeMnSiC__MO_427873955970_002
pair_coeff * * C
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 12.0107

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 45384.7996524405 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_427873955970_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.56 | 14.56 | 14.56 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -58423.538     -58423.538     -58767.999     -58767.999      333.15         333.15         45384.8        45384.8        8106.7808      8106.7808    
      1000  -58045.424     -58045.424     -58401.32      -58401.32       344.20883      344.20883      45736.476      45736.476     -2268.6321     -2268.6321    
Loop time of 1057.21 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 293.669 hours/ns, 0.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1055.3     | 1055.3     | 1055.3     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34308    | 0.34308    | 0.34308    |   0.0 |  0.03
Output  | 0.0002879  | 0.0002879  | 0.0002879  |   0.0 |  0.00
Modify  | 1.3884     | 1.3884     | 1.3884     |   0.0 |  0.13
Other   |            | 0.1774     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:    2.192e+06 ave   2.192e+06 max   2.192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2192000
Ave neighs/atom = 274
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -58045.424     -58045.424     -58401.32      -58401.32       344.20883      344.20883      45736.476      45736.476     -2268.6321     -2268.6321    
      2000  -58081.573     -58081.573     -58433.451     -58433.451      340.32366      340.32366      45704.563      45704.563     -1469.2665     -1469.2665    
Loop time of 1076.43 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.008 hours/ns, 0.929 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1074.5     | 1074.5     | 1074.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34761    | 0.34761    | 0.34761    |   0.0 |  0.03
Output  | 0.00035185 | 0.00035185 | 0.00035185 |   0.0 |  0.00
Modify  | 1.4358     | 1.4358     | 1.4358     |   0.0 |  0.13
Other   |            | 0.1808     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191880
Ave neighs/atom = 273.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -58081.573     -58081.573     -58433.451     -58433.451      340.32366      340.32366      45704.563      45704.563     -1469.2665     -1469.2665    
      3000  -58065.998     -58065.998     -58417.597     -58417.597      340.0537       340.0537       45685.934      45685.934      983.41475      983.41475    
Loop time of 1084.97 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 301.381 hours/ns, 0.922 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1083       | 1083       | 1083       |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34879    | 0.34879    | 0.34879    |   0.0 |  0.03
Output  | 0.00027945 | 0.00027945 | 0.00027945 |   0.0 |  0.00
Modify  | 1.4435     | 1.4435     | 1.4435     |   0.0 |  0.13
Other   |            | 0.1816     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191934
Ave neighs/atom = 273.99175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -58065.998     -58065.998     -58417.597     -58417.597      340.0537       340.0537       45685.934      45685.934      983.41475      983.41475    
      4000  -58069.727     -58069.727     -58401.956     -58401.956      321.31958      321.31958      45705.355      45705.355     -95.846738     -95.846738    
Loop time of 1079.33 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.813 hours/ns, 0.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1077.4     | 1077.4     | 1077.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34735    | 0.34735    | 0.34735    |   0.0 |  0.03
Output  | 0.00028034 | 0.00028034 | 0.00028034 |   0.0 |  0.00
Modify  | 1.4322     | 1.4322     | 1.4322     |   0.0 |  0.13
Other   |            | 0.1799     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191908
Ave neighs/atom = 273.9885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -58069.727     -58069.727     -58401.956     -58401.956      321.31958      321.31958      45705.355      45705.355     -95.846738     -95.846738    
      5000  -58074.496     -58074.496     -58411.522     -58411.522      325.95868      325.95868      45710.497      45710.497     -997.09354     -997.09354    
Loop time of 1076.73 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.093 hours/ns, 0.929 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1074.8     | 1074.8     | 1074.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34736    | 0.34736    | 0.34736    |   0.0 |  0.03
Output  | 0.00023422 | 0.00023422 | 0.00023422 |   0.0 |  0.00
Modify  | 1.4304     | 1.4304     | 1.4304     |   0.0 |  0.13
Other   |            | 0.1789     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191878
Ave neighs/atom = 273.98475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.705512480686, Press = -452.966240253708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -58074.496     -58074.496     -58411.522     -58411.522      325.95868      325.95868      45710.497      45710.497     -997.09354     -997.09354    
      6000  -58064.202     -58064.202     -58409.268     -58409.268      333.73475      333.73475      45665.063      45665.063      3546.6286      3546.6286    
Loop time of 1062.32 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.089 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.4     | 1060.4     | 1060.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34079    | 0.34079    | 0.34079    |   0.0 |  0.03
Output  | 0.00023896 | 0.00023896 | 0.00023896 |   0.0 |  0.00
Modify  | 1.4347     | 1.4347     | 1.4347     |   0.0 |  0.14
Other   |            | 0.1781     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191890
Ave neighs/atom = 273.98625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.72233943524, Press = -12.956082364429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -58064.202     -58064.202     -58409.268     -58409.268      333.73475      333.73475      45665.063      45665.063      3546.6286      3546.6286    
      7000  -58076.515     -58076.515     -58415.071     -58415.071      327.43891      327.43891      45711.515      45711.515     -1158.7937     -1158.7937    
Loop time of 1066.25 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.180 hours/ns, 0.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1064.3     | 1064.3     | 1064.3     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34574    | 0.34574    | 0.34574    |   0.0 |  0.03
Output  | 0.00023814 | 0.00023814 | 0.00023814 |   0.0 |  0.00
Modify  | 1.4462     | 1.4462     | 1.4462     |   0.0 |  0.14
Other   |            | 0.1792     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191926
Ave neighs/atom = 273.99075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.988128497668, Press = 47.1319801713593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -58076.515     -58076.515     -58415.071     -58415.071      327.43891      327.43891      45711.515      45711.515     -1158.7937     -1158.7937    
      8000  -58065.565     -58065.565     -58410.101     -58410.101      333.22314      333.22314      45723.333      45723.333     -2056.4999     -2056.4999    
Loop time of 1062.5 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.139 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.5     | 1060.5     | 1060.5     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34468    | 0.34468    | 0.34468    |   0.0 |  0.03
Output  | 0.0002319  | 0.0002319  | 0.0002319  |   0.0 |  0.00
Modify  | 1.4431     | 1.4431     | 1.4431     |   0.0 |  0.14
Other   |            | 0.1782     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191912
Ave neighs/atom = 273.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.098470206401, Press = -19.0325626924472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -58065.565     -58065.565     -58410.101     -58410.101      333.22314      333.22314      45723.333      45723.333     -2056.4999     -2056.4999    
      9000  -58072.887     -58072.887     -58418.454     -58418.454      334.21897      334.21897      45684.353      45684.353      1204.4333      1204.4333    
Loop time of 1077.91 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.420 hours/ns, 0.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1075.9     | 1075.9     | 1075.9     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34475    | 0.34475    | 0.34475    |   0.0 |  0.03
Output  | 0.00028473 | 0.00028473 | 0.00028473 |   0.0 |  0.00
Modify  | 1.4571     | 1.4571     | 1.4571     |   0.0 |  0.14
Other   |            | 0.1792     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19187e+06 ave 2.19187e+06 max 2.19187e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191866
Ave neighs/atom = 273.98325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.015017157867, Press = -2.04648017472445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -58072.887     -58072.887     -58418.454     -58418.454      334.21897      334.21897      45684.353      45684.353      1204.4333      1204.4333    
     10000  -58072.794     -58072.794     -58419.445     -58419.445      335.26757      335.26757      45701.786      45701.786     -375.65306     -375.65306    
Loop time of 1080.06 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.016 hours/ns, 0.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1078.1     | 1078.1     | 1078.1     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34492    | 0.34492    | 0.34492    |   0.0 |  0.03
Output  | 0.0002403  | 0.0002403  | 0.0002403  |   0.0 |  0.00
Modify  | 1.4616     | 1.4616     | 1.4616     |   0.0 |  0.14
Other   |            | 0.1798     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19187e+06 ave 2.19187e+06 max 2.19187e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191872
Ave neighs/atom = 273.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.133735155872, Press = 3.54391227857006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -58072.794     -58072.794     -58419.445     -58419.445      335.26757      335.26757      45701.786      45701.786     -375.65306     -375.65306    
     11000  -58063.949     -58063.949     -58414.06      -58414.06       338.61411      338.61411      45715.683      45715.683     -1227.4792     -1227.4792    
Loop time of 1097.6 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 304.888 hours/ns, 0.911 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1095.6     | 1095.6     | 1095.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34914    | 0.34914    | 0.34914    |   0.0 |  0.03
Output  | 0.00023713 | 0.00023713 | 0.00023713 |   0.0 |  0.00
Modify  | 1.493      | 1.493      | 1.493      |   0.0 |  0.14
Other   |            | 0.1827     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191888
Ave neighs/atom = 273.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.126629339815, Press = -4.87057058122352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -58063.949     -58063.949     -58414.06      -58414.06       338.61411      338.61411      45715.683      45715.683     -1227.4792     -1227.4792    
     12000  -58072.869     -58072.869     -58418.33      -58418.33       334.11722      334.11722      45679.825      45679.825      1580.5306      1580.5306    
Loop time of 1085.55 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 301.541 hours/ns, 0.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1083.5     | 1083.5     | 1083.5     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34908    | 0.34908    | 0.34908    |   0.0 |  0.03
Output  | 0.00030706 | 0.00030706 | 0.00030706 |   0.0 |  0.00
Modify  | 1.4909     | 1.4909     | 1.4909     |   0.0 |  0.14
Other   |            | 0.1819     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191904
Ave neighs/atom = 273.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.288403549443, Press = -3.74445630956357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -58072.869     -58072.869     -58418.33      -58418.33       334.11722      334.11722      45679.825      45679.825      1580.5306      1580.5306    
     13000  -58065.198     -58065.198     -58414.949     -58414.949      338.2666       338.2666       45702.209      45702.209     -140.34123     -140.34123    
Loop time of 1073.25 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 298.125 hours/ns, 0.932 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1071.3     | 1071.3     | 1071.3     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34506    | 0.34506    | 0.34506    |   0.0 |  0.03
Output  | 0.0002358  | 0.0002358  | 0.0002358  |   0.0 |  0.00
Modify  | 1.4637     | 1.4637     | 1.4637     |   0.0 |  0.14
Other   |            | 0.1805     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191914
Ave neighs/atom = 273.98925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.41941721086, Press = 9.56305984076815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -58065.198     -58065.198     -58414.949     -58414.949      338.2666       338.2666       45702.209      45702.209     -140.34123     -140.34123    
     14000  -58074.575     -58074.575     -58419.235     -58419.235      333.34261      333.34261      45734.342      45734.342     -3440.5602     -3440.5602    
Loop time of 1072.4 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.888 hours/ns, 0.932 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1070.4     | 1070.4     | 1070.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34545    | 0.34545    | 0.34545    |   0.0 |  0.03
Output  | 0.00028382 | 0.00028382 | 0.00028382 |   0.0 |  0.00
Modify  | 1.4489     | 1.4489     | 1.4489     |   0.0 |  0.14
Other   |            | 0.1806     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191906
Ave neighs/atom = 273.98825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.34191811722, Press = -6.64912798486091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -58074.575     -58074.575     -58419.235     -58419.235      333.34261      333.34261      45734.342      45734.342     -3440.5602     -3440.5602    
     15000  -58075.123     -58075.123     -58418.021     -58418.021      331.63888      331.63888      45666.646      45666.646      2707.0083      2707.0083    
Loop time of 1076.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.897 hours/ns, 0.929 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1074       | 1074       | 1074       |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34638    | 0.34638    | 0.34638    |   0.0 |  0.03
Output  | 0.00023756 | 0.00023756 | 0.00023756 |   0.0 |  0.00
Modify  | 1.4641     | 1.4641     | 1.4641     |   0.0 |  0.14
Other   |            | 0.1805     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191890
Ave neighs/atom = 273.98625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.31535945603, Press = -4.68720711522236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -58075.123     -58075.123     -58418.021     -58418.021      331.63888      331.63888      45666.646      45666.646      2707.0083      2707.0083    
     16000  -58070.458     -58070.458     -58415.695     -58415.695      333.90111      333.90111      45696.946      45696.946      263.30759      263.30759    
Loop time of 1069.3 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.028 hours/ns, 0.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1067.3     | 1067.3     | 1067.3     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34438    | 0.34438    | 0.34438    |   0.0 |  0.03
Output  | 0.00037577 | 0.00037577 | 0.00037577 |   0.0 |  0.00
Modify  | 1.4549     | 1.4549     | 1.4549     |   0.0 |  0.14
Other   |            | 0.1786     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191914
Ave neighs/atom = 273.98925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.13352720674, Press = 6.59297783892727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -58070.458     -58070.458     -58415.695     -58415.695      333.90111      333.90111      45696.946      45696.946      263.30759      263.30759    
     17000  -58075.992     -58075.992     -58416.682     -58416.682      329.50266      329.50266      45722.932      45722.932     -2299.7904     -2299.7904    
Loop time of 1087.9 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 302.193 hours/ns, 0.919 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1085.9     | 1085.9     | 1085.9     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34892    | 0.34892    | 0.34892    |   0.0 |  0.03
Output  | 0.00028717 | 0.00028717 | 0.00028717 |   0.0 |  0.00
Modify  | 1.4792     | 1.4792     | 1.4792     |   0.0 |  0.14
Other   |            | 0.1807     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191924
Ave neighs/atom = 273.9905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.109799871077, Press = -3.70896245466324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -58075.992     -58075.992     -58416.682     -58416.682      329.50266      329.50266      45722.932      45722.932     -2299.7904     -2299.7904    
     18000  -58066.545     -58066.545     -58417.208     -58417.208      339.14851      339.14851      45678.051      45678.051      2128.4759      2128.4759    
Loop time of 1088.11 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 302.254 hours/ns, 0.919 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1086.1     | 1086.1     | 1086.1     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3462     | 0.3462     | 0.3462     |   0.0 |  0.03
Output  | 0.00029432 | 0.00029432 | 0.00029432 |   0.0 |  0.00
Modify  | 1.4666     | 1.4666     | 1.4666     |   0.0 |  0.13
Other   |            | 0.1794     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191898
Ave neighs/atom = 273.98725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.001921680823, Press = -2.4764460073015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -58066.545     -58066.545     -58417.208     -58417.208      339.14851      339.14851      45678.051      45678.051      2128.4759      2128.4759    
     19000  -58077.676     -58077.676     -58418.368     -58418.368      329.50431      329.50431      45696.794      45696.794      17.654867      17.654867    
Loop time of 1089.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 302.509 hours/ns, 0.918 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1087       | 1087       | 1087       |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.03
Output  | 0.00023461 | 0.00023461 | 0.00023461 |   0.0 |  0.00
Modify  | 1.49       | 1.49       | 1.49       |   0.0 |  0.14
Other   |            | 0.1826     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191918
Ave neighs/atom = 273.98975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942932068656, Press = 4.57845577787726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -58077.676     -58077.676     -58418.368     -58418.368      329.50431      329.50431      45696.794      45696.794      17.654867      17.654867    
     20000  -58069.586     -58069.586     -58415.798     -58415.798      334.84385      334.84385      45734.947      45734.947     -3307.3852     -3307.3852    
Loop time of 1100.26 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 305.627 hours/ns, 0.909 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1098.2     | 1098.2     | 1098.2     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.35317    | 0.35317    | 0.35317    |   0.0 |  0.03
Output  | 0.00030753 | 0.00030753 | 0.00030753 |   0.0 |  0.00
Modify  | 1.5072     | 1.5072     | 1.5072     |   0.0 |  0.14
Other   |            | 0.1833     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191916
Ave neighs/atom = 273.9895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.951590765058, Press = -4.08071345910588
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -58069.586     -58069.586     -58415.798     -58415.798      334.84385      334.84385      45734.947      45734.947     -3307.3852     -3307.3852    
     21000  -58071.55      -58071.55      -58417.198     -58417.198      334.29762      334.29762      45658.814      45658.814      3727.0524      3727.0524    
Loop time of 1076.41 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.004 hours/ns, 0.929 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1074.4     | 1074.4     | 1074.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34538    | 0.34538    | 0.34538    |   0.0 |  0.03
Output  | 0.00023786 | 0.00023786 | 0.00023786 |   0.0 |  0.00
Modify  | 1.4621     | 1.4621     | 1.4621     |   0.0 |  0.14
Other   |            | 0.1796     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191880
Ave neighs/atom = 273.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.994187218857, Press = -3.19706434396463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -58071.55      -58071.55      -58417.198     -58417.198      334.29762      334.29762      45658.814      45658.814      3727.0524      3727.0524    
     22000  -58076.017     -58076.017     -58417.349     -58417.349      330.12337      330.12337      45695.688      45695.688      137.66349      137.66349    
Loop time of 1091.8 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 303.278 hours/ns, 0.916 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1089.8     | 1089.8     | 1089.8     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34949    | 0.34949    | 0.34949    |   0.0 |  0.03
Output  | 0.00023674 | 0.00023674 | 0.00023674 |   0.0 |  0.00
Modify  | 1.4967     | 1.4967     | 1.4967     |   0.0 |  0.14
Other   |            | 0.1821     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191912
Ave neighs/atom = 273.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.05827366962, Press = 3.70841367021336
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -58076.017     -58076.017     -58417.349     -58417.349      330.12337      330.12337      45695.688      45695.688      137.66349      137.66349    
     23000  -58065.071     -58065.071     -58413.506     -58413.506      336.99255      336.99255      45717.173      45717.173     -1403.2989     -1403.2989    
Loop time of 1089.46 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 302.627 hours/ns, 0.918 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1087.4     | 1087.4     | 1087.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34782    | 0.34782    | 0.34782    |   0.0 |  0.03
Output  | 0.00032078 | 0.00032078 | 0.00032078 |   0.0 |  0.00
Modify  | 1.477      | 1.477      | 1.477      |   0.0 |  0.14
Other   |            | 0.1818     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191886
Ave neighs/atom = 273.98575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.050232163676, Press = -1.44412667912636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -58065.071     -58065.071     -58413.506     -58413.506      336.99255      336.99255      45717.173      45717.173     -1403.2989     -1403.2989    
     24000  -58072.724     -58072.724     -58414.819     -58414.819      330.86199      330.86199      45687.446      45687.446      1064.6044      1064.6044    
Loop time of 1089.86 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.079 ns/day, 302.740 hours/ns, 0.918 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1087.8     | 1087.8     | 1087.8     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34914    | 0.34914    | 0.34914    |   0.0 |  0.03
Output  | 0.0002444  | 0.0002444  | 0.0002444  |   0.0 |  0.00
Modify  | 1.4901     | 1.4901     | 1.4901     |   0.0 |  0.14
Other   |            | 0.1824     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191902
Ave neighs/atom = 273.98775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.003830410723, Press = -0.888410074855786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -58072.724     -58072.724     -58414.819     -58414.819      330.86199      330.86199      45687.446      45687.446      1064.6044      1064.6044    
     25000  -58068.227     -58068.227     -58411.335     -58411.335      331.84175      331.84175      45698.743      45698.743      263.08156      263.08156    
Loop time of 1082.75 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.765 hours/ns, 0.924 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1080.7     | 1080.7     | 1080.7     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34977    | 0.34977    | 0.34977    |   0.0 |  0.03
Output  | 0.00035822 | 0.00035822 | 0.00035822 |   0.0 |  0.00
Modify  | 1.4786     | 1.4786     | 1.4786     |   0.0 |  0.14
Other   |            | 0.18       |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191912
Ave neighs/atom = 273.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974095930427, Press = 2.16480288668602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -58068.227     -58068.227     -58411.335     -58411.335      331.84175      331.84175      45698.743      45698.743      263.08156      263.08156    
     26000  -58072.157     -58072.157     -58414.017     -58414.017      330.63429      330.63429      45756.603      45756.603     -5224.4368     -5224.4368    
Loop time of 1085.42 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 301.505 hours/ns, 0.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1083.4     | 1083.4     | 1083.4     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34719    | 0.34719    | 0.34719    |   0.0 |  0.03
Output  | 0.00023643 | 0.00023643 | 0.00023643 |   0.0 |  0.00
Modify  | 1.4826     | 1.4826     | 1.4826     |   0.0 |  0.14
Other   |            | 0.1817     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191932
Ave neighs/atom = 273.9915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.902429865197, Press = -3.02692121528857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -58072.157     -58072.157     -58414.017     -58414.017      330.63429      330.63429      45756.603      45756.603     -5224.4368     -5224.4368    
     27000  -58072.84      -58072.84      -58416.786     -58416.786      332.65202      332.65202      45668.17       45668.17       2918.2596      2918.2596    
Loop time of 1081.47 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.407 hours/ns, 0.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1079.5     | 1079.5     | 1079.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34653    | 0.34653    | 0.34653    |   0.0 |  0.03
Output  | 0.00028668 | 0.00028668 | 0.00028668 |   0.0 |  0.00
Modify  | 1.461      | 1.461      | 1.461      |   0.0 |  0.14
Other   |            | 0.1788     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19183e+06 ave 2.19183e+06 max 2.19183e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191832
Ave neighs/atom = 273.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905181397488, Press = -2.79550605357645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -58072.84      -58072.84      -58416.786     -58416.786      332.65202      332.65202      45668.17       45668.17       2918.2596      2918.2596    
     28000  -58071.226     -58071.226     -58417.053     -58417.053      334.47145      334.47145      45696.117      45696.117      246.9882       246.9882     
Loop time of 1085.21 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 301.449 hours/ns, 0.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1083.2     | 1083.2     | 1083.2     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34991    | 0.34991    | 0.34991    |   0.0 |  0.03
Output  | 0.00028401 | 0.00028401 | 0.00028401 |   0.0 |  0.00
Modify  | 1.4779     | 1.4779     | 1.4779     |   0.0 |  0.14
Other   |            | 0.1802     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191922
Ave neighs/atom = 273.99025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.841805747401, Press = 2.33945262738634
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -58071.226     -58071.226     -58417.053     -58417.053      334.47145      334.47145      45696.117      45696.117      246.9882       246.9882     
     29000  -58072.16      -58072.16      -58417.372     -58417.372      333.87655      333.87655      45717.818      45717.818     -1684.465      -1684.465     
Loop time of 1082.93 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.813 hours/ns, 0.923 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1080.9     | 1080.9     | 1080.9     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34856    | 0.34856    | 0.34856    |   0.0 |  0.03
Output  | 0.00028932 | 0.00028932 | 0.00028932 |   0.0 |  0.00
Modify  | 1.4714     | 1.4714     | 1.4714     |   0.0 |  0.14
Other   |            | 0.1797     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191900
Ave neighs/atom = 273.9875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.858357668512, Press = -1.08274372224571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -58072.16      -58072.16      -58417.372     -58417.372      333.87655      333.87655      45717.818      45717.818     -1684.465      -1684.465     
     30000  -58067.223     -58067.223     -58416.998     -58416.998      338.28865      338.28865      45684.158      45684.158      1579.6121      1579.6121    
Loop time of 1081.21 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.336 hours/ns, 0.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1079.2     | 1079.2     | 1079.2     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34729    | 0.34729    | 0.34729    |   0.0 |  0.03
Output  | 0.00030833 | 0.00030833 | 0.00030833 |   0.0 |  0.00
Modify  | 1.4691     | 1.4691     | 1.4691     |   0.0 |  0.14
Other   |            | 0.1795     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191884
Ave neighs/atom = 273.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.850236128212, Press = -1.24575715946723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -58067.223     -58067.223     -58416.998     -58416.998      338.28865      338.28865      45684.158      45684.158      1579.6121      1579.6121    
     31000  -58078.549     -58078.549     -58418.29      -58418.29       328.58514      328.58514      45689.636      45689.636      603.3576       603.3576     
Loop time of 1080.99 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.276 hours/ns, 0.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1079       | 1079       | 1079       |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34711    | 0.34711    | 0.34711    |   0.0 |  0.03
Output  | 0.00023391 | 0.00023391 | 0.00023391 |   0.0 |  0.00
Modify  | 1.4564     | 1.4564     | 1.4564     |   0.0 |  0.13
Other   |            | 0.1775     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19194e+06 ave 2.19194e+06 max 2.19194e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191940
Ave neighs/atom = 273.9925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.830555043555, Press = 4.73438170766956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -58078.549     -58078.549     -58418.29      -58418.29       328.58514      328.58514      45689.636      45689.636      603.3576       603.3576     
     32000  -58068.376     -58068.376     -58414.937     -58414.937      335.18153      335.18153      45748.699      45748.699     -4410.6439     -4410.6439    
Loop time of 1079.76 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.933 hours/ns, 0.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1077.8     | 1077.8     | 1077.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34714    | 0.34714    | 0.34714    |   0.0 |  0.03
Output  | 0.0003507  | 0.0003507  | 0.0003507  |   0.0 |  0.00
Modify  | 1.4501     | 1.4501     | 1.4501     |   0.0 |  0.13
Other   |            | 0.1779     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191912
Ave neighs/atom = 273.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.813218629625, Press = -1.85989783816114
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -58068.376     -58068.376     -58414.937     -58414.937      335.18153      335.18153      45748.699      45748.699     -4410.6439     -4410.6439    
     33000  -58073.036     -58073.036     -58418.994     -58418.994      334.5975       334.5975       45678.4        45678.4        1781.3514      1781.3514    
Loop time of 1071.75 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.708 hours/ns, 0.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1069.8     | 1069.8     | 1069.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34572    | 0.34572    | 0.34572    |   0.0 |  0.03
Output  | 0.00023279 | 0.00023279 | 0.00023279 |   0.0 |  0.00
Modify  | 1.4558     | 1.4558     | 1.4558     |   0.0 |  0.14
Other   |            | 0.1783     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191886
Ave neighs/atom = 273.98575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.868739422509, Press = -1.5825117331398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -58073.036     -58073.036     -58418.994     -58418.994      334.5975       334.5975       45678.4        45678.4        1781.3514      1781.3514    
     34000  -58063.668     -58063.668     -58412.355     -58412.355      337.23722      337.23722      45696.516      45696.516      550.90897      550.90897    
Loop time of 1071.43 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.619 hours/ns, 0.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1069.5     | 1069.5     | 1069.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34383    | 0.34383    | 0.34383    |   0.0 |  0.03
Output  | 0.00030804 | 0.00030804 | 0.00030804 |   0.0 |  0.00
Modify  | 1.4491     | 1.4491     | 1.4491     |   0.0 |  0.14
Other   |            | 0.1784     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191904
Ave neighs/atom = 273.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913184267205, Press = 1.84808844487308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -58063.668     -58063.668     -58412.355     -58412.355      337.23722      337.23722      45696.516      45696.516      550.90897      550.90897    
     35000  -58074.389     -58074.389     -58416.713     -58416.713      331.08321      331.08321      45722.807      45722.807     -2377.5975     -2377.5975    
Loop time of 1071.97 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.768 hours/ns, 0.933 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1070       | 1070       | 1070       |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34378    | 0.34378    | 0.34378    |   0.0 |  0.03
Output  | 0.00028606 | 0.00028606 | 0.00028606 |   0.0 |  0.00
Modify  | 1.4498     | 1.4498     | 1.4498     |   0.0 |  0.14
Other   |            | 0.1779     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191886
Ave neighs/atom = 273.98575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.950127464811, Press = -0.720591228405643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -58074.389     -58074.389     -58416.713     -58416.713      331.08321      331.08321      45722.807      45722.807     -2377.5975     -2377.5975    
     36000  -58069.283     -58069.283     -58411.823     -58411.823      331.29276      331.29276      45675.848      45675.848      2463.3498      2463.3498    
Loop time of 1073.83 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.286 hours/ns, 0.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1071.9     | 1071.9     | 1071.9     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34501    | 0.34501    | 0.34501    |   0.0 |  0.03
Output  | 0.00030944 | 0.00030944 | 0.00030944 |   0.0 |  0.00
Modify  | 1.4565     | 1.4565     | 1.4565     |   0.0 |  0.14
Other   |            | 0.178      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191888
Ave neighs/atom = 273.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.964669965559, Press = -1.78723741902127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -58069.283     -58069.283     -58411.823     -58411.823      331.29276      331.29276      45675.848      45675.848      2463.3498      2463.3498    
     37000  -58071.225     -58071.225     -58413.95      -58413.95       331.4712       331.4712       45671.254      45671.254      2715.6308      2715.6308    
Loop time of 1080.81 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.224 hours/ns, 0.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1078.8     | 1078.8     | 1078.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34555    | 0.34555    | 0.34555    |   0.0 |  0.03
Output  | 0.00024541 | 0.00024541 | 0.00024541 |   0.0 |  0.00
Modify  | 1.4555     | 1.4555     | 1.4555     |   0.0 |  0.13
Other   |            | 0.1786     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191920
Ave neighs/atom = 273.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978973527468, Press = 6.13892156142107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -58071.225     -58071.225     -58413.95      -58413.95       331.4712       331.4712       45671.254      45671.254      2715.6308      2715.6308    
     38000  -58067.451     -58067.451     -58414.028     -58414.028      335.19653      335.19653      45739.746      45739.746     -3717.2782     -3717.2782    
Loop time of 1069.61 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.115 hours/ns, 0.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1067.6     | 1067.6     | 1067.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3467     | 0.3467     | 0.3467     |   0.0 |  0.03
Output  | 0.00024032 | 0.00024032 | 0.00024032 |   0.0 |  0.00
Modify  | 1.443      | 1.443      | 1.443      |   0.0 |  0.13
Other   |            | 0.1767     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191928
Ave neighs/atom = 273.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.941830109526, Press = -0.549360568528807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -58067.451     -58067.451     -58414.028     -58414.028      335.19653      335.19653      45739.746      45739.746     -3717.2782     -3717.2782    
     39000  -58072.286     -58072.286     -58414.634     -58414.634      331.1058       331.1058       45680.077      45680.077      1849.2007      1849.2007    
Loop time of 1066.76 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.321 hours/ns, 0.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1064.8     | 1064.8     | 1064.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34431    | 0.34431    | 0.34431    |   0.0 |  0.03
Output  | 0.00023274 | 0.00023274 | 0.00023274 |   0.0 |  0.00
Modify  | 1.4418     | 1.4418     | 1.4418     |   0.0 |  0.14
Other   |            | 0.1772     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191878
Ave neighs/atom = 273.98475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.952160081056, Press = -1.00487680342332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -58072.286     -58072.286     -58414.634     -58414.634      331.1058       331.1058       45680.077      45680.077      1849.2007      1849.2007    
     40000  -58063.602     -58063.602     -58411.124     -58411.124      336.11071      336.11071      45698.413      45698.413      483.17889      483.17889    
Loop time of 1067 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.388 hours/ns, 0.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1065       | 1065       | 1065       |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3447     | 0.3447     | 0.3447     |   0.0 |  0.03
Output  | 0.00028392 | 0.00028392 | 0.00028392 |   0.0 |  0.00
Modify  | 1.4365     | 1.4365     | 1.4365     |   0.0 |  0.13
Other   |            | 0.1762     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191884
Ave neighs/atom = 273.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.966319522519, Press = 1.60715020175676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -58063.602     -58063.602     -58411.124     -58411.124      336.11071      336.11071      45698.413      45698.413      483.17889      483.17889    
     41000  -58072.681     -58072.681     -58414.802     -58414.802      330.88676      330.88676      45723.522      45723.522     -2207.924      -2207.924     
Loop time of 1069.2 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.000 hours/ns, 0.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1067.2     | 1067.2     | 1067.2     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34527    | 0.34527    | 0.34527    |   0.0 |  0.03
Output  | 0.00029033 | 0.00029033 | 0.00029033 |   0.0 |  0.00
Modify  | 1.457      | 1.457      | 1.457      |   0.0 |  0.14
Other   |            | 0.1764     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191884
Ave neighs/atom = 273.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.970879879671, Press = -0.542805140315649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -58072.681     -58072.681     -58414.802     -58414.802      330.88676      330.88676      45723.522      45723.522     -2207.924      -2207.924     
     42000  -58067.912     -58067.912     -58413.729     -58413.729      334.46174      334.46174      45668.011      45668.011      3122.419       3122.419     
Loop time of 1078.42 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.562 hours/ns, 0.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1076.4     | 1076.4     | 1076.4     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34692    | 0.34692    | 0.34692    |   0.0 |  0.03
Output  | 0.00029094 | 0.00029094 | 0.00029094 |   0.0 |  0.00
Modify  | 1.4621     | 1.4621     | 1.4621     |   0.0 |  0.14
Other   |            | 0.1792     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191882
Ave neighs/atom = 273.98525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.985423089817, Press = -1.77979072202259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -58067.912     -58067.912     -58413.729     -58413.729      334.46174      334.46174      45668.011      45668.011      3122.419       3122.419     
     43000  -58075.175     -58075.175     -58423.333     -58423.333      336.72558      336.72558      45682.695      45682.695      1175.8828      1175.8828    
Loop time of 1070.53 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.369 hours/ns, 0.934 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1068.6     | 1068.6     | 1068.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34279    | 0.34279    | 0.34279    |   0.0 |  0.03
Output  | 0.00023743 | 0.00023743 | 0.00023743 |   0.0 |  0.00
Modify  | 1.4335     | 1.4335     | 1.4335     |   0.0 |  0.13
Other   |            | 0.1756     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191934
Ave neighs/atom = 273.99175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.983329937698, Press = 3.55708654536909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -58075.175     -58075.175     -58423.333     -58423.333      336.72558      336.72558      45682.695      45682.695      1175.8828      1175.8828    
     44000  -58074.251     -58074.251     -58415.302     -58415.302      329.85199      329.85199      45724.118      45724.118     -2191.0815     -2191.0815    
Loop time of 1066.23 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.175 hours/ns, 0.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1064.3     | 1064.3     | 1064.3     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34083    | 0.34083    | 0.34083    |   0.0 |  0.03
Output  | 0.00024719 | 0.00024719 | 0.00024719 |   0.0 |  0.00
Modify  | 1.4374     | 1.4374     | 1.4374     |   0.0 |  0.13
Other   |            | 0.1771     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191924
Ave neighs/atom = 273.9905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974933382406, Press = -0.302346988308277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -58074.251     -58074.251     -58415.302     -58415.302      329.85199      329.85199      45724.118      45724.118     -2191.0815     -2191.0815    
     45000  -58069.596     -58069.596     -58416.037     -58416.037      335.0649       335.0649       45687.025      45687.025      1291.8263      1291.8263    
Loop time of 1070.63 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.397 hours/ns, 0.934 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1068.6     | 1068.6     | 1068.6     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34723    | 0.34723    | 0.34723    |   0.0 |  0.03
Output  | 0.00056308 | 0.00056308 | 0.00056308 |   0.0 |  0.00
Modify  | 1.4646     | 1.4646     | 1.4646     |   0.0 |  0.14
Other   |            | 0.1782     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191888
Ave neighs/atom = 273.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.943868197338, Press = -0.637643726573261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -58069.596     -58069.596     -58416.037     -58416.037      335.0649       335.0649       45687.025      45687.025      1291.8263      1291.8263    
     46000  -58071.45      -58071.45      -58415.139     -58415.139      332.40305      332.40305      45692.415      45692.415      773.43233      773.43233    
Loop time of 1080.07 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.021 hours/ns, 0.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1078.1     | 1078.1     | 1078.1     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34863    | 0.34863    | 0.34863    |   0.0 |  0.03
Output  | 0.00023475 | 0.00023475 | 0.00023475 |   0.0 |  0.00
Modify  | 1.4826     | 1.4826     | 1.4826     |   0.0 |  0.14
Other   |            | 0.1798     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191898
Ave neighs/atom = 273.98725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.953686293173, Press = 1.35440738980983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -58071.45      -58071.45      -58415.139     -58415.139      332.40305      332.40305      45692.415      45692.415      773.43233      773.43233    
     47000  -58073.341     -58073.341     -58413.064     -58413.064      328.56749      328.56749      45732.21       45732.21      -2944.0478     -2944.0478    
Loop time of 1059.55 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 294.319 hours/ns, 0.944 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1057.6     | 1057.6     | 1057.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34268    | 0.34268    | 0.34268    |   0.0 |  0.03
Output  | 0.00032916 | 0.00032916 | 0.00032916 |   0.0 |  0.00
Modify  | 1.4381     | 1.4381     | 1.4381     |   0.0 |  0.14
Other   |            | 0.1759     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191890
Ave neighs/atom = 273.98625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.92072498545, Press = -0.524619064460639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -58073.341     -58073.341     -58413.064     -58413.064      328.56749      328.56749      45732.21       45732.21      -2944.0478     -2944.0478    
     48000  -58070.795     -58070.795     -58418.053     -58418.053      335.85518      335.85518      45657.23       45657.23       3855.5219      3855.5219    
Loop time of 1057.79 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 293.830 hours/ns, 0.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1055.8     | 1055.8     | 1055.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3401     | 0.3401     | 0.3401     |   0.0 |  0.03
Output  | 0.00023607 | 0.00023607 | 0.00023607 |   0.0 |  0.00
Modify  | 1.4251     | 1.4251     | 1.4251     |   0.0 |  0.13
Other   |            | 0.1758     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191880
Ave neighs/atom = 273.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913716491317, Press = -1.96886255878171
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -58070.795     -58070.795     -58418.053     -58418.053      335.85518      335.85518      45657.23       45657.23       3855.5219      3855.5219    
     49000  -58068.846     -58068.846     -58417.429     -58417.429      337.13592      337.13592      45692.155      45692.155      688.50298      688.50298    
Loop time of 1062.85 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.236 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.9     | 1060.9     | 1060.9     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34353    | 0.34353    | 0.34353    |   0.0 |  0.03
Output  | 0.0002349  | 0.0002349  | 0.0002349  |   0.0 |  0.00
Modify  | 1.4298     | 1.4298     | 1.4298     |   0.0 |  0.13
Other   |            | 0.1762     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191926
Ave neighs/atom = 273.99075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.9089829329, Press = 1.83619609612902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -58068.846     -58068.846     -58417.429     -58417.429      337.13592      337.13592      45692.155      45692.155      688.50298      688.50298    
     50000  -58074.2       -58074.2       -58412.376     -58412.376      327.07069      327.07069      45714.329      45714.329     -1258.5301     -1258.5301    
Loop time of 1057.71 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 293.808 hours/ns, 0.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1055.8     | 1055.8     | 1055.8     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34215    | 0.34215    | 0.34215    |   0.0 |  0.03
Output  | 0.00023712 | 0.00023712 | 0.00023712 |   0.0 |  0.00
Modify  | 1.4374     | 1.4374     | 1.4374     |   0.0 |  0.14
Other   |            | 0.178      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191928
Ave neighs/atom = 273.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.91731558188, Press = -0.118837961879852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -58074.2       -58074.2       -58412.376     -58412.376      327.07069      327.07069      45714.329      45714.329     -1258.5301     -1258.5301    
     51000  -58067.595     -58067.595     -58408.945     -58408.945      330.141        330.141        45688.437      45688.437      1367.0125      1367.0125    
Loop time of 1058.44 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 294.011 hours/ns, 0.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1056.5     | 1056.5     | 1056.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.33958    | 0.33958    | 0.33958    |   0.0 |  0.03
Output  | 0.00024013 | 0.00024013 | 0.00024013 |   0.0 |  0.00
Modify  | 1.4197     | 1.4197     | 1.4197     |   0.0 |  0.13
Other   |            | 0.1772     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19187e+06 ave 2.19187e+06 max 2.19187e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191872
Ave neighs/atom = 273.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.888037706176, Press = -0.481961403745913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -58067.595     -58067.595     -58408.945     -58408.945      330.141        330.141        45688.437      45688.437      1367.0125      1367.0125    
     52000  -58074.446     -58074.446     -58419.078     -58419.078      333.31526      333.31526      45689.9        45689.9        557.97196      557.97196    
Loop time of 1062.03 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.008 hours/ns, 0.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.1     | 1060.1     | 1060.1     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34347    | 0.34347    | 0.34347    |   0.0 |  0.03
Output  | 0.00028867 | 0.00028867 | 0.00028867 |   0.0 |  0.00
Modify  | 1.4359     | 1.4359     | 1.4359     |   0.0 |  0.14
Other   |            | 0.1775     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191928
Ave neighs/atom = 273.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.882988856687, Press = 1.69220744171798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -58074.446     -58074.446     -58419.078     -58419.078      333.31526      333.31526      45689.9        45689.9        557.97196      557.97196    
     53000  -58064.204     -58064.204     -58408.155     -58408.155      332.65705      332.65705      45756.33       45756.33      -4840.3024     -4840.3024    
Loop time of 1063.76 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.489 hours/ns, 0.940 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1061.8     | 1061.8     | 1061.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34007    | 0.34007    | 0.34007    |   0.0 |  0.03
Output  | 0.00028903 | 0.00028903 | 0.00028903 |   0.0 |  0.00
Modify  | 1.4287     | 1.4287     | 1.4287     |   0.0 |  0.13
Other   |            | 0.1757     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191918
Ave neighs/atom = 273.98975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.898904036647, Press = -0.831139735303341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -58064.204     -58064.204     -58408.155     -58408.155      332.65705      332.65705      45756.33       45756.33      -4840.3024     -4840.3024    
     54000  -58070.329     -58070.329     -58412.231     -58412.231      330.67538      330.67538      45674.552      45674.552      2540.2513      2540.2513    
Loop time of 1060.67 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 294.630 hours/ns, 0.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1058.7     | 1058.7     | 1058.7     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34458    | 0.34458    | 0.34458    |   0.0 |  0.03
Output  | 0.00036771 | 0.00036771 | 0.00036771 |   0.0 |  0.00
Modify  | 1.4351     | 1.4351     | 1.4351     |   0.0 |  0.14
Other   |            | 0.1763     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19184e+06 ave 2.19184e+06 max 2.19184e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191840
Ave neighs/atom = 273.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920000341441, Press = -1.11234645514743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -58070.329     -58070.329     -58412.231     -58412.231      330.67538      330.67538      45674.552      45674.552      2540.2513      2540.2513    
     55000  -58067.615     -58067.615     -58414.337     -58414.337      335.33695      335.33695      45695.738      45695.738      416.51047      416.51047    
Loop time of 1077.2 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.223 hours/ns, 0.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1075.2     | 1075.2     | 1075.2     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34354    | 0.34354    | 0.34354    |   0.0 |  0.03
Output  | 0.00024575 | 0.00024575 | 0.00024575 |   0.0 |  0.00
Modify  | 1.4475     | 1.4475     | 1.4475     |   0.0 |  0.13
Other   |            | 0.1784     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191918
Ave neighs/atom = 273.98975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.953187523475, Press = 0.775998513391404
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -58067.615     -58067.615     -58414.337     -58414.337      335.33695      335.33695      45695.738      45695.738      416.51047      416.51047    
     56000  -58075.398     -58075.398     -58420.472     -58420.472      333.74251      333.74251      45712.166      45712.166     -1516.5227     -1516.5227    
Loop time of 1077.27 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 299.243 hours/ns, 0.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1075.3     | 1075.3     | 1075.3     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34484    | 0.34484    | 0.34484    |   0.0 |  0.03
Output  | 0.00028868 | 0.00028868 | 0.00028868 |   0.0 |  0.00
Modify  | 1.4622     | 1.4622     | 1.4622     |   0.0 |  0.14
Other   |            | 0.1783     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191918
Ave neighs/atom = 273.98975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945908252084, Press = -0.0143872756085217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -58075.398     -58075.398     -58420.472     -58420.472      333.74251      333.74251      45712.166      45712.166     -1516.5227     -1516.5227    
     57000  -58074.307     -58074.307     -58418.704     -58418.704      333.08775      333.08775      45687.433      45687.433      1013.9001      1013.9001    
Loop time of 1066.42 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.229 hours/ns, 0.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1064.5     | 1064.5     | 1064.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34244    | 0.34244    | 0.34244    |   0.0 |  0.03
Output  | 0.00024134 | 0.00024134 | 0.00024134 |   0.0 |  0.00
Modify  | 1.4345     | 1.4345     | 1.4345     |   0.0 |  0.13
Other   |            | 0.1766     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191896
Ave neighs/atom = 273.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.949395562759, Press = -0.730854546644981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -58074.307     -58074.307     -58418.704     -58418.704      333.08775      333.08775      45687.433      45687.433      1013.9001      1013.9001    
     58000  -58072.251     -58072.251     -58417.58      -58417.58       333.99007      333.99007      45675.762      45675.762      2229.8378      2229.8378    
Loop time of 1064.57 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.715 hours/ns, 0.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1062.6     | 1062.6     | 1062.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34053    | 0.34053    | 0.34053    |   0.0 |  0.03
Output  | 0.00023368 | 0.00023368 | 0.00023368 |   0.0 |  0.00
Modify  | 1.4284     | 1.4284     | 1.4284     |   0.0 |  0.13
Other   |            | 0.1759     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191916
Ave neighs/atom = 273.9895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.917215195532, Press = 1.7463945196918
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -58072.251     -58072.251     -58417.58      -58417.58       333.99007      333.99007      45675.762      45675.762      2229.8378      2229.8378    
     59000  -58073.417     -58073.417     -58415.257     -58415.257      330.61481      330.61481      45745.674      45745.674     -4333.2059     -4333.2059    
Loop time of 1062.19 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.052 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.2     | 1060.2     | 1060.2     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34222    | 0.34222    | 0.34222    |   0.0 |  0.03
Output  | 0.00029043 | 0.00029043 | 0.00029043 |   0.0 |  0.00
Modify  | 1.4505     | 1.4505     | 1.4505     |   0.0 |  0.14
Other   |            | 0.1765     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19195e+06 ave 2.19195e+06 max 2.19195e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191950
Ave neighs/atom = 273.99375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919075086772, Press = 0.0145092253651615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -58073.417     -58073.417     -58415.257     -58415.257      330.61481      330.61481      45745.674      45745.674     -4333.2059     -4333.2059    
     60000  -58067.851     -58067.851     -58409.534     -58409.534      330.4627       330.4627       45687.843      45687.843      1437.5377      1437.5377    
Loop time of 1055.63 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 293.230 hours/ns, 0.947 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1053.7     | 1053.7     | 1053.7     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34217    | 0.34217    | 0.34217    |   0.0 |  0.03
Output  | 0.00023523 | 0.00023523 | 0.00023523 |   0.0 |  0.00
Modify  | 1.4263     | 1.4263     | 1.4263     |   0.0 |  0.14
Other   |            | 0.1756     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191898
Ave neighs/atom = 273.98725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.891204576075, Press = -0.991674684416458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -58067.851     -58067.851     -58409.534     -58409.534      330.4627       330.4627       45687.843      45687.843      1437.5377      1437.5377    
     61000  -58073.604     -58073.604     -58413.922     -58413.922      329.14248      329.14248      45679.387      45679.387      1718.6095      1718.6095    
Loop time of 1058.6 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 294.055 hours/ns, 0.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1056.6     | 1056.6     | 1056.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34159    | 0.34159    | 0.34159    |   0.0 |  0.03
Output  | 0.0003769  | 0.0003769  | 0.0003769  |   0.0 |  0.00
Modify  | 1.4356     | 1.4356     | 1.4356     |   0.0 |  0.14
Other   |            | 0.1761     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191896
Ave neighs/atom = 273.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.896257062136, Press = 1.24546910348682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -58073.604     -58073.604     -58413.922     -58413.922      329.14248      329.14248      45679.387      45679.387      1718.6095      1718.6095    
     62000  -58065.986     -58065.986     -58411.111     -58411.111      333.79119      333.79119      45732.912      45732.912     -2731.4423     -2731.4423    
Loop time of 1062.57 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.157 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1060.6     | 1060.6     | 1060.6     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34209    | 0.34209    | 0.34209    |   0.0 |  0.03
Output  | 0.00023227 | 0.00023227 | 0.00023227 |   0.0 |  0.00
Modify  | 1.4495     | 1.4495     | 1.4495     |   0.0 |  0.14
Other   |            | 0.1779     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19192e+06 ave 2.19192e+06 max 2.19192e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191918
Ave neighs/atom = 273.98975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.896536465299, Press = 0.260453500856604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -58065.986     -58065.986     -58411.111     -58411.111      333.79119      333.79119      45732.912      45732.912     -2731.4423     -2731.4423    
     63000  -58073.028     -58073.028     -58412.935     -58412.935      328.74556      328.74556      45689.961      45689.961      1054.3383      1054.3383    
Loop time of 1061.44 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 294.844 hours/ns, 0.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1059.5     | 1059.5     | 1059.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34313    | 0.34313    | 0.34313    |   0.0 |  0.03
Output  | 0.00027544 | 0.00027544 | 0.00027544 |   0.0 |  0.00
Modify  | 1.4352     | 1.4352     | 1.4352     |   0.0 |  0.14
Other   |            | 0.177      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19186e+06 ave 2.19186e+06 max 2.19186e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191858
Ave neighs/atom = 273.98225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.889099911123, Press = -0.952987142849203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -58073.028     -58073.028     -58412.935     -58412.935      328.74556      328.74556      45689.961      45689.961      1054.3383      1054.3383    
     64000  -58069.666     -58069.666     -58417.978     -58417.978      336.87475      336.87475      45674.867      45674.867      2427.0279      2427.0279    
Loop time of 1067.11 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.419 hours/ns, 0.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1065.1     | 1065.1     | 1065.1     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34455    | 0.34455    | 0.34455    |   0.0 |  0.03
Output  | 0.00031779 | 0.00031779 | 0.00031779 |   0.0 |  0.00
Modify  | 1.4421     | 1.4421     | 1.4421     |   0.0 |  0.14
Other   |            | 0.176      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191928
Ave neighs/atom = 273.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.881305197966, Press = 1.13359952790922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -58069.666     -58069.666     -58417.978     -58417.978      336.87475      336.87475      45674.867      45674.867      2427.0279      2427.0279    
     65000  -58066.236     -58066.236     -58408.118     -58408.118      330.65578      330.65578      45737.292      45737.292     -3145.3912     -3145.3912    
Loop time of 1062.96 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.266 hours/ns, 0.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1061       | 1061       | 1061       |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34394    | 0.34394    | 0.34394    |   0.0 |  0.03
Output  | 0.00023614 | 0.00023614 | 0.00023614 |   0.0 |  0.00
Modify  | 1.4269     | 1.4269     | 1.4269     |   0.0 |  0.13
Other   |            | 0.1753     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19195e+06 ave 2.19195e+06 max 2.19195e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191948
Ave neighs/atom = 273.9935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.86416141065, Press = 0.587649260064091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -58066.236     -58066.236     -58408.118     -58408.118      330.65578      330.65578      45737.292      45737.292     -3145.3912     -3145.3912    
     66000  -58067.39      -58067.39      -58412.008     -58412.008      333.30158      333.30158      45697.987      45697.987      249.10227      249.10227    
Loop time of 1064.72 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 295.755 hours/ns, 0.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1062.8     | 1062.8     | 1062.8     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34374    | 0.34374    | 0.34374    |   0.0 |  0.03
Output  | 0.00023316 | 0.00023316 | 0.00023316 |   0.0 |  0.00
Modify  | 1.4408     | 1.4408     | 1.4408     |   0.0 |  0.14
Other   |            | 0.1777     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19185e+06 ave 2.19185e+06 max 2.19185e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191854
Ave neighs/atom = 273.98175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872010579556, Press = -1.06097018102635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -58067.39      -58067.39      -58412.008     -58412.008      333.30158      333.30158      45697.987      45697.987      249.10227      249.10227    
     67000  -58060.984     -58060.984     -58404.657     -58404.657      332.38816      332.38816      45686.233      45686.233      1826.9803      1826.9803    
Loop time of 1069.43 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.065 hours/ns, 0.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1067.4     | 1067.4     | 1067.4     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3461     | 0.3461     | 0.3461     |   0.0 |  0.03
Output  | 0.00031312 | 0.00031312 | 0.00031312 |   0.0 |  0.00
Modify  | 1.4711     | 1.4711     | 1.4711     |   0.0 |  0.14
Other   |            | 0.179      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191902
Ave neighs/atom = 273.98775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879953001342, Press = 0.637256004014861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -58060.984     -58060.984     -58404.657     -58404.657      332.38816      332.38816      45686.233      45686.233      1826.9803      1826.9803    
     68000  -58072.417     -58072.417     -58416.038     -58416.038      332.33737      332.33737      45712.68       45712.68      -1341.508      -1341.508     
Loop time of 1067.44 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.510 hours/ns, 0.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1065.5     | 1065.5     | 1065.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34088    | 0.34088    | 0.34088    |   0.0 |  0.03
Output  | 0.00028675 | 0.00028675 | 0.00028675 |   0.0 |  0.00
Modify  | 1.4342     | 1.4342     | 1.4342     |   0.0 |  0.13
Other   |            | 0.1752     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191892
Ave neighs/atom = 273.9865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905269028051, Press = 0.423093677156842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -58072.417     -58072.417     -58416.038     -58416.038      332.33737      332.33737      45712.68       45712.68      -1341.508      -1341.508     
     69000  -58067.899     -58067.899     -58416.819     -58416.819      337.46295      337.46295      45700.848      45700.848     -135.95837     -135.95837    
Loop time of 1059.57 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 294.325 hours/ns, 0.944 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1057.6     | 1057.6     | 1057.6     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.33952    | 0.33952    | 0.33952    |   0.0 |  0.03
Output  | 0.00023636 | 0.00023636 | 0.00023636 |   0.0 |  0.00
Modify  | 1.4234     | 1.4234     | 1.4234     |   0.0 |  0.13
Other   |            | 0.1749     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19186e+06 ave 2.19186e+06 max 2.19186e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191862
Ave neighs/atom = 273.98275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907760986267, Press = -0.326684421160238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -58067.899     -58067.899     -58416.819     -58416.819      337.46295      337.46295      45700.848      45700.848     -135.95837     -135.95837    
     70000  -58074.95      -58074.95      -58413.297     -58413.297      327.23699      327.23699      45692.1        45692.1        626.89723      626.89723    
Loop time of 1073.42 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.172 hours/ns, 0.932 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1071.5     | 1071.5     | 1071.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34245    | 0.34245    | 0.34245    |   0.0 |  0.03
Output  | 0.0002952  | 0.0002952  | 0.0002952  |   0.0 |  0.00
Modify  | 1.4384     | 1.4384     | 1.4384     |   0.0 |  0.13
Other   |            | 0.1771     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191900
Ave neighs/atom = 273.9875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.912923008042, Press = 0.232484622305108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -58074.95      -58074.95      -58413.297     -58413.297      327.23699      327.23699      45692.1        45692.1        626.89723      626.89723    
     71000  -58068.423     -58068.423     -58415.748     -58415.748      335.9197       335.9197       45706.093      45706.093     -563.60123     -563.60123    
Loop time of 1082.21 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 300.613 hours/ns, 0.924 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1080.2     | 1080.2     | 1080.2     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34966    | 0.34966    | 0.34966    |   0.0 |  0.03
Output  | 0.00031833 | 0.00031833 | 0.00031833 |   0.0 |  0.00
Modify  | 1.4804     | 1.4804     | 1.4804     |   0.0 |  0.14
Other   |            | 0.1798     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19187e+06 ave 2.19187e+06 max 2.19187e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191870
Ave neighs/atom = 273.98375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.903668545061, Press = 0.0951062926367835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -58068.423     -58068.423     -58415.748     -58415.748      335.9197       335.9197       45706.093      45706.093     -563.60123     -563.60123    
     72000  -58076.497     -58076.497     -58419.6       -58419.6        331.83629      331.83629      45693.68       45693.68       214.80134      214.80134    
Loop time of 1074.02 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.340 hours/ns, 0.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1072       | 1072       | 1072       |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34544    | 0.34544    | 0.34544    |   0.0 |  0.03
Output  | 0.00024058 | 0.00024058 | 0.00024058 |   0.0 |  0.00
Modify  | 1.4629     | 1.4629     | 1.4629     |   0.0 |  0.14
Other   |            | 0.1788     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19189e+06 ave 2.19189e+06 max 2.19189e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191890
Ave neighs/atom = 273.98625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.89019022907, Press = -0.0655485614685487
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -58076.497     -58076.497     -58419.6       -58419.6        331.83629      331.83629      45693.68       45693.68       214.80134      214.80134    
     73000  -58066.751     -58066.751     -58413.412     -58413.412      335.27708      335.27708      45702.237      45702.237     -7.6794003     -7.6794003    
Loop time of 1066.46 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 296.239 hours/ns, 0.938 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1064.5     | 1064.5     | 1064.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34354    | 0.34354    | 0.34354    |   0.0 |  0.03
Output  | 0.00023208 | 0.00023208 | 0.00023208 |   0.0 |  0.00
Modify  | 1.4424     | 1.4424     | 1.4424     |   0.0 |  0.14
Other   |            | 0.1768     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191912
Ave neighs/atom = 273.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.895683481274, Press = 0.215077289236263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -58066.751     -58066.751     -58413.412     -58413.412      335.27708      335.27708      45702.237      45702.237     -7.6794003     -7.6794003    
     74000  -58073.479     -58073.479     -58417.493     -58417.493      332.71758      332.71758      45703.123      45703.123     -452.9836      -452.9836     
Loop time of 1056.31 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.082 ns/day, 293.419 hours/ns, 0.947 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1054.3     | 1054.3     | 1054.3     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34162    | 0.34162    | 0.34162    |   0.0 |  0.03
Output  | 0.00036593 | 0.00036593 | 0.00036593 |   0.0 |  0.00
Modify  | 1.4419     | 1.4419     | 1.4419     |   0.0 |  0.14
Other   |            | 0.1765     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19188e+06 ave 2.19188e+06 max 2.19188e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191884
Ave neighs/atom = 273.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913464805715, Press = -0.151361137391124
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -58073.479     -58073.479     -58417.493     -58417.493      332.71758      332.71758      45703.123      45703.123     -452.9836      -452.9836     
     75000  -58060.233     -58060.233     -58413.824     -58413.824      341.97992      341.97992      45693.122      45693.122      976.30076      976.30076    
Loop time of 1075.63 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.787 hours/ns, 0.930 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1073.6     | 1073.6     | 1073.6     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3479     | 0.3479     | 0.3479     |   0.0 |  0.03
Output  | 0.00024022 | 0.00024022 | 0.00024022 |   0.0 |  0.00
Modify  | 1.4785     | 1.4785     | 1.4785     |   0.0 |  0.14
Other   |            | 0.1794     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19191e+06 ave 2.19191e+06 max 2.19191e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191914
Ave neighs/atom = 273.98925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.924348845998, Press = 0.0314254754009661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -58060.233     -58060.233     -58413.824     -58413.824      341.97992      341.97992      45693.122      45693.122      976.30076      976.30076    
     76000  -58073.35      -58073.35      -58418.508     -58418.508      333.82435      333.82435      45707.146      45707.146     -774.46927     -774.46927    
Loop time of 1074.51 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.474 hours/ns, 0.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1072.5     | 1072.5     | 1072.5     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.3467     | 0.3467     | 0.3467     |   0.0 |  0.03
Output  | 0.0024214  | 0.0024214  | 0.0024214  |   0.0 |  0.00
Modify  | 1.4616     | 1.4616     | 1.4616     |   0.0 |  0.14
Other   |            | 0.1794     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19193e+06 ave 2.19193e+06 max 2.19193e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191928
Ave neighs/atom = 273.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.94367727352, Press = 0.563315580402173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -58073.35      -58073.35      -58418.508     -58418.508      333.82435      333.82435      45707.146      45707.146     -774.46927     -774.46927    
     77000  -58064.734     -58064.734     -58415.539     -58415.539      339.2851       339.2851       45717.949      45717.949     -1445.1107     -1445.1107    
Loop time of 1073.68 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.080 ns/day, 298.245 hours/ns, 0.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1071.7     | 1071.7     | 1071.7     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34416    | 0.34416    | 0.34416    |   0.0 |  0.03
Output  | 0.00024219 | 0.00024219 | 0.00024219 |   0.0 |  0.00
Modify  | 1.4541     | 1.4541     | 1.4541     |   0.0 |  0.14
Other   |            | 0.178      |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:  2.19194e+06 ave 2.19194e+06 max 2.19194e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191936
Ave neighs/atom = 273.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.964314122716, Press = -0.924391074531283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 14.81 | 14.81 | 14.81 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -58064.734     -58064.734     -58415.539     -58415.539      339.2851       339.2851       45717.949      45717.949     -1445.1107     -1445.1107    
     78000  -58068.144     -58068.144     -58416.227     -58416.227      336.6524       336.6524       45659.904      45659.904      3677.7341      3677.7341    
Loop time of 1069.46 on 1 procs for 1000 steps with 8000 atoms

Performance: 0.081 ns/day, 297.072 hours/ns, 0.935 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 1067.5     | 1067.5     | 1067.5     |   0.0 | 99.82
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.34345    | 0.34345    | 0.34345    |   0.0 |  0.03
Output  | 0.00023867 | 0.00023867 | 0.00023867 |   0.0 |  0.00
Modify  | 1.4548     | 1.4548     | 1.4548     |   0.0 |  0.14
Other   |            | 0.1778     |            |       |  0.02

Nlocal:           8000 ave        8000 max        8000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:          12817 ave       12817 max       12817 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:   2.1919e+06 ave  2.1919e+06 max  2.1919e+06 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 2191900
Ave neighs/atom = 273.9875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
45699.9671939144

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0