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

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuMo__MO_380272712420_002
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31153.5557782513 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_380272712420_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13533.917     -13533.917     -13620         -13620          333.15         333.15         31153.556      31153.556      2951.4166      2951.4166    
      1000  -13444.991     -13444.991     -13540.897     -13540.897      371.16625      371.16625      31332.638      31332.638     -742.81896     -742.81896    
Loop time of 49.3498 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.751 ns/day, 13.708 hours/ns, 20.264 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.264     | 49.264     | 49.264     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019511   | 0.019511   | 0.019511   |   0.0 |  0.04
Output  | 0.0001318  | 0.0001318  | 0.0001318  |   0.0 |  0.00
Modify  | 0.059926   | 0.059926   | 0.059926   |   0.0 |  0.12
Other   |            | 0.006206   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272000 ave      272000 max      272000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272000
Ave neighs/atom = 136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13444.991     -13444.991     -13540.897     -13540.897      371.16625      371.16625      31332.638      31332.638     -742.81896     -742.81896    
      2000  -13444.169     -13444.169     -13528.094     -13528.094      324.79657      324.79657      31347.529      31347.529     -337.97724     -337.97724    
Loop time of 51.3416 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.262 hours/ns, 19.477 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.257     | 51.257     | 51.257     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019271   | 0.019271   | 0.019271   |   0.0 |  0.04
Output  | 3.9354e-05 | 3.9354e-05 | 3.9354e-05 |   0.0 |  0.00
Modify  | 0.059504   | 0.059504   | 0.059504   |   0.0 |  0.12
Other   |            | 0.00629    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272112 ave      272112 max      272112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272112
Ave neighs/atom = 136.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13444.169     -13444.169     -13528.094     -13528.094      324.79657      324.79657      31347.529      31347.529     -337.97724     -337.97724    
      3000  -13447.557     -13447.557     -13531.478     -13531.478      324.78104      324.78104      31331.627      31331.627      389.52342      389.52342    
Loop time of 51.3341 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.259 hours/ns, 19.480 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.249     | 51.249     | 51.249     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019258   | 0.019258   | 0.019258   |   0.0 |  0.04
Output  | 4.0777e-05 | 4.0777e-05 | 4.0777e-05 |   0.0 |  0.00
Modify  | 0.059516   | 0.059516   | 0.059516   |   0.0 |  0.12
Other   |            | 0.006226   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5457 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272168 ave      272168 max      272168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272168
Ave neighs/atom = 136.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13447.557     -13447.557     -13531.478     -13531.478      324.78104      324.78104      31331.627      31331.627      389.52342      389.52342    
      4000  -13442.6       -13442.6       -13536.528     -13536.528      363.51334      363.51334      31298.596      31298.596      2763.1684      2763.1684    
Loop time of 51.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.264 hours/ns, 19.475 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.264     | 51.264     | 51.264     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019371   | 0.019371   | 0.019371   |   0.0 |  0.04
Output  | 4.8281e-05 | 4.8281e-05 | 4.8281e-05 |   0.0 |  0.00
Modify  | 0.05956    | 0.05956    | 0.05956    |   0.0 |  0.12
Other   |            | 0.006264   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272152 ave      272152 max      272152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272152
Ave neighs/atom = 136.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13442.6       -13442.6       -13536.528     -13536.528      363.51334      363.51334      31298.596      31298.596      2763.1684      2763.1684    
      5000  -13447.32      -13447.32      -13533.967     -13533.967      335.33108      335.33108      31295.136      31295.136      3087.3907      3087.3907    
Loop time of 51.3269 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.257 hours/ns, 19.483 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.242     | 51.242     | 51.242     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019335   | 0.019335   | 0.019335   |   0.0 |  0.04
Output  | 3.1209e-05 | 3.1209e-05 | 3.1209e-05 |   0.0 |  0.00
Modify  | 0.05978    | 0.05978    | 0.05978    |   0.0 |  0.12
Other   |            | 0.006196   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272120 ave      272120 max      272120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272120
Ave neighs/atom = 136.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.257473741376, Press = -225.196669210363
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13447.32      -13447.32      -13533.967     -13533.967      335.33108      335.33108      31295.136      31295.136      3087.3907      3087.3907    
      6000  -13442.951     -13442.951     -13527.799     -13527.799      328.37027      328.37027      31343.008      31343.008     -283.08349     -283.08349    
Loop time of 51.4877 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.302 hours/ns, 19.422 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.4       | 51.4       | 51.4       |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019357   | 0.019357   | 0.019357   |   0.0 |  0.04
Output  | 3.179e-05  | 3.179e-05  | 3.179e-05  |   0.0 |  0.00
Modify  | 0.061934   | 0.061934   | 0.061934   |   0.0 |  0.12
Other   |            | 0.006307   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5466 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.549735111235, Press = -38.1335418666876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13442.951     -13442.951     -13527.799     -13527.799      328.37027      328.37027      31343.008      31343.008     -283.08349     -283.08349    
      7000  -13446.343     -13446.343     -13533.061     -13533.061      335.60798      335.60798      31344.311      31344.311     -812.74774     -812.74774    
Loop time of 51.4007 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.278 hours/ns, 19.455 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.313     | 51.313     | 51.313     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019322   | 0.019322   | 0.019322   |   0.0 |  0.04
Output  | 3.182e-05  | 3.182e-05  | 3.182e-05  |   0.0 |  0.00
Modify  | 0.061917   | 0.061917   | 0.061917   |   0.0 |  0.12
Other   |            | 0.006281   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272230 ave      272230 max      272230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272230
Ave neighs/atom = 136.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.602116534177, Press = -35.7099854507368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13446.343     -13446.343     -13533.061     -13533.061      335.60798      335.60798      31344.311      31344.311     -812.74774     -812.74774    
      8000  -13442.979     -13442.979     -13532.461     -13532.461      346.30535      346.30535      31336.043      31336.043     -63.736896     -63.736896    
Loop time of 51.3486 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.263 hours/ns, 19.475 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.261     | 51.261     | 51.261     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01939    | 0.01939    | 0.01939    |   0.0 |  0.04
Output  | 3.2081e-05 | 3.2081e-05 | 3.2081e-05 |   0.0 |  0.00
Modify  | 0.061895   | 0.061895   | 0.061895   |   0.0 |  0.12
Other   |            | 0.006308   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5466 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272124 ave      272124 max      272124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272124
Ave neighs/atom = 136.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.55426575895, Press = -32.089404757083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13442.979     -13442.979     -13532.461     -13532.461      346.30535      346.30535      31336.043      31336.043     -63.736896     -63.736896    
      9000  -13444.122     -13444.122     -13533.776     -13533.776      346.97024      346.97024      31309.456      31309.456      2016.1285      2016.1285    
Loop time of 51.4522 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.292 hours/ns, 19.436 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.365     | 51.365     | 51.365     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019214   | 0.019214   | 0.019214   |   0.0 |  0.04
Output  | 4.1098e-05 | 4.1098e-05 | 4.1098e-05 |   0.0 |  0.00
Modify  | 0.061934   | 0.061934   | 0.061934   |   0.0 |  0.12
Other   |            | 0.006189   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5452 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272146 ave      272146 max      272146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272146
Ave neighs/atom = 136.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934087273534, Press = -22.5793772127886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13444.122     -13444.122     -13533.776     -13533.776      346.97024      346.97024      31309.456      31309.456      2016.1285      2016.1285    
     10000  -13449.971     -13449.971     -13536.432     -13536.432      334.61171      334.61171      31277.901      31277.901      4192.4027      4192.4027    
Loop time of 51.5235 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.312 hours/ns, 19.409 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.436     | 51.436     | 51.436     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019376   | 0.019376   | 0.019376   |   0.0 |  0.04
Output  | 3.9785e-05 | 3.9785e-05 | 3.9785e-05 |   0.0 |  0.00
Modify  | 0.062041   | 0.062041   | 0.062041   |   0.0 |  0.12
Other   |            | 0.006118   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272194 ave      272194 max      272194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272194
Ave neighs/atom = 136.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.276515530014, Press = 5.08468691256715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13449.971     -13449.971     -13536.432     -13536.432      334.61171      334.61171      31277.901      31277.901      4192.4027      4192.4027    
     11000  -13443.973     -13443.973     -13531.875     -13531.875      340.18962      340.18962      31365.864      31365.864     -2618.9756     -2618.9756    
Loop time of 51.4751 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.299 hours/ns, 19.427 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.388     | 51.388     | 51.388     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019332   | 0.019332   | 0.019332   |   0.0 |  0.04
Output  | 7.7286e-05 | 7.7286e-05 | 7.7286e-05 |   0.0 |  0.00
Modify  | 0.061887   | 0.061887   | 0.061887   |   0.0 |  0.12
Other   |            | 0.006049   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272148 ave      272148 max      272148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272148
Ave neighs/atom = 136.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.982127809678, Press = 3.2967336709793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13443.973     -13443.973     -13531.875     -13531.875      340.18962      340.18962      31365.864      31365.864     -2618.9756     -2618.9756    
     12000  -13447.222     -13447.222     -13531.996     -13531.996      328.08398      328.08398      31356.359      31356.359     -1842.7744     -1842.7744    
Loop time of 51.4638 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.296 hours/ns, 19.431 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.377     | 51.377     | 51.377     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019367   | 0.019367   | 0.019367   |   0.0 |  0.04
Output  | 3.2522e-05 | 3.2522e-05 | 3.2522e-05 |   0.0 |  0.00
Modify  | 0.061851   | 0.061851   | 0.061851   |   0.0 |  0.12
Other   |            | 0.005988   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5452 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272130 ave      272130 max      272130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272130
Ave neighs/atom = 136.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.692422955556, Press = -10.1035226038786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13447.222     -13447.222     -13531.996     -13531.996      328.08398      328.08398      31356.359      31356.359     -1842.7744     -1842.7744    
     13000  -13447.615     -13447.615     -13532.661     -13532.661      329.13857      329.13857      31335.015      31335.015     -301.95372     -301.95372    
Loop time of 51.4115 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.281 hours/ns, 19.451 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.324     | 51.324     | 51.324     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019229   | 0.019229   | 0.019229   |   0.0 |  0.04
Output  | 3.189e-05  | 3.189e-05  | 3.189e-05  |   0.0 |  0.00
Modify  | 0.061809   | 0.061809   | 0.061809   |   0.0 |  0.12
Other   |            | 0.005998   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5457 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272168 ave      272168 max      272168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272168
Ave neighs/atom = 136.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.76935920029, Press = -10.7771300646274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13447.615     -13447.615     -13532.661     -13532.661      329.13857      329.13857      31335.015      31335.015     -301.95372     -301.95372    
     14000  -13440.852     -13440.852     -13528.173     -13528.173      337.93979      337.93979      31319.87       31319.87       1777.2192      1777.2192    
Loop time of 51.464 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.296 hours/ns, 19.431 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.377     | 51.377     | 51.377     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019295   | 0.019295   | 0.019295   |   0.0 |  0.04
Output  | 5.6227e-05 | 5.6227e-05 | 5.6227e-05 |   0.0 |  0.00
Modify  | 0.061712   | 0.061712   | 0.061712   |   0.0 |  0.12
Other   |            | 0.006013   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272184 ave      272184 max      272184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272184
Ave neighs/atom = 136.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.132533865669, Press = -8.33839619368763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13440.852     -13440.852     -13528.173     -13528.173      337.93979      337.93979      31319.87       31319.87       1777.2192      1777.2192    
     15000  -13445.155     -13445.155     -13532.297     -13532.297      337.25221      337.25221      31306.02       31306.02       2377.112       2377.112     
Loop time of 51.6408 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.673 ns/day, 14.345 hours/ns, 19.365 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.554     | 51.554     | 51.554     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019273   | 0.019273   | 0.019273   |   0.0 |  0.04
Output  | 3.2191e-05 | 3.2191e-05 | 3.2191e-05 |   0.0 |  0.00
Modify  | 0.061876   | 0.061876   | 0.061876   |   0.0 |  0.12
Other   |            | 0.005995   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5464 ave        5464 max        5464 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272172 ave      272172 max      272172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272172
Ave neighs/atom = 136.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.215644391685, Press = -1.56100782648216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13445.155     -13445.155     -13532.297     -13532.297      337.25221      337.25221      31306.02       31306.02       2377.112       2377.112     
     16000  -13446.937     -13446.937     -13532.482     -13532.482      331.0688       331.0688       31357.908      31357.908     -1974.093      -1974.093     
Loop time of 51.4368 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.288 hours/ns, 19.441 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.35      | 51.35      | 51.35      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019259   | 0.019259   | 0.019259   |   0.0 |  0.04
Output  | 2.3244e-05 | 2.3244e-05 | 2.3244e-05 |   0.0 |  0.00
Modify  | 0.061781   | 0.061781   | 0.061781   |   0.0 |  0.12
Other   |            | 0.005965   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272144 ave      272144 max      272144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272144
Ave neighs/atom = 136.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.204173580208, Press = 0.302874979087072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13446.937     -13446.937     -13532.482     -13532.482      331.0688       331.0688       31357.908      31357.908     -1974.093      -1974.093     
     17000  -13443.499     -13443.499     -13529.321     -13529.321      332.14278      332.14278      31371.969      31371.969     -2805.2712     -2805.2712    
Loop time of 51.5465 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.676 ns/day, 14.318 hours/ns, 19.400 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.459     | 51.459     | 51.459     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019324   | 0.019324   | 0.019324   |   0.0 |  0.04
Output  | 3.5497e-05 | 3.5497e-05 | 3.5497e-05 |   0.0 |  0.00
Modify  | 0.061746   | 0.061746   | 0.061746   |   0.0 |  0.12
Other   |            | 0.005981   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5467 ave        5467 max        5467 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272152 ave      272152 max      272152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272152
Ave neighs/atom = 136.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.942186419068, Press = -6.04713346523392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13443.499     -13443.499     -13529.321     -13529.321      332.14278      332.14278      31371.969      31371.969     -2805.2712     -2805.2712    
     18000  -13446.71      -13446.71      -13533.186     -13533.186      334.67452      334.67452      31337.935      31337.935     -501.83894     -501.83894    
Loop time of 51.3907 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.275 hours/ns, 19.459 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.304     | 51.304     | 51.304     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019239   | 0.019239   | 0.019239   |   0.0 |  0.04
Output  | 3.2341e-05 | 3.2341e-05 | 3.2341e-05 |   0.0 |  0.00
Modify  | 0.0618     | 0.0618     | 0.0618     |   0.0 |  0.12
Other   |            | 0.00603    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5457 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272124 ave      272124 max      272124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272124
Ave neighs/atom = 136.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.983720981858, Press = -6.28067839057131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13446.71      -13446.71      -13533.186     -13533.186      334.67452      334.67452      31337.935      31337.935     -501.83894     -501.83894    
     19000  -13443.666     -13443.666     -13531.524     -13531.524      340.02065      340.02065      31328.695      31328.695      742.92284      742.92284    
Loop time of 51.5913 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.675 ns/day, 14.331 hours/ns, 19.383 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.504     | 51.504     | 51.504     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019209   | 0.019209   | 0.019209   |   0.0 |  0.04
Output  | 3.21e-05   | 3.21e-05   | 3.21e-05   |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.12
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272142 ave      272142 max      272142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272142
Ave neighs/atom = 136.071
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.167892349038, Press = -4.29118681335208
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13443.666     -13443.666     -13531.524     -13531.524      340.02065      340.02065      31328.695      31328.695      742.92284      742.92284    
     20000  -13445.746     -13445.746     -13531.534     -13531.534      332.0109       332.0109       31323.722      31323.722      1020.2023      1020.2023    
Loop time of 51.5039 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.307 hours/ns, 19.416 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.417     | 51.417     | 51.417     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019356   | 0.019356   | 0.019356   |   0.0 |  0.04
Output  | 3.3333e-05 | 3.3333e-05 | 3.3333e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.12
Other   |            | 0.006015   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361906802176, Press = -2.32122735849557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13445.746     -13445.746     -13531.534     -13531.534      332.0109       332.0109       31323.722      31323.722      1020.2023      1020.2023    
     21000  -13442.846     -13442.846     -13529.303     -13529.303      334.59849      334.59849      31355.201      31355.201     -1402.7765     -1402.7765    
Loop time of 51.3776 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.272 hours/ns, 19.464 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.291     | 51.291     | 51.291     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019212   | 0.019212   | 0.019212   |   0.0 |  0.04
Output  | 3.187e-05  | 3.187e-05  | 3.187e-05  |   0.0 |  0.00
Modify  | 0.061676   | 0.061676   | 0.061676   |   0.0 |  0.12
Other   |            | 0.00597    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5464 ave        5464 max        5464 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272144 ave      272144 max      272144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272144
Ave neighs/atom = 136.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383433377225, Press = -1.60698436835881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13442.846     -13442.846     -13529.303     -13529.303      334.59849      334.59849      31355.201      31355.201     -1402.7765     -1402.7765    
     22000  -13447.201     -13447.201     -13532.525     -13532.525      330.2145       330.2145       31367.632      31367.632     -2901.0745     -2901.0745    
Loop time of 51.4166 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.282 hours/ns, 19.449 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.33      | 51.33      | 51.33      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019255   | 0.019255   | 0.019255   |   0.0 |  0.04
Output  | 3.207e-05  | 3.207e-05  | 3.207e-05  |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.12
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5440 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.231072049334, Press = -5.45510474921352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13447.201     -13447.201     -13532.525     -13532.525      330.2145       330.2145       31367.632      31367.632     -2901.0745     -2901.0745    
     23000  -13443.272     -13443.272     -13533.064     -13533.064      347.50755      347.50755      31335.605      31335.605     -24.961039     -24.961039    
Loop time of 51.5962 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.675 ns/day, 14.332 hours/ns, 19.381 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.509     | 51.509     | 51.509     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019253   | 0.019253   | 0.019253   |   0.0 |  0.04
Output  | 2.3244e-05 | 2.3244e-05 | 2.3244e-05 |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.12
Other   |            | 0.005957   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5456 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272116 ave      272116 max      272116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272116
Ave neighs/atom = 136.058
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.15633571855, Press = -6.82554919528401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13443.272     -13443.272     -13533.064     -13533.064      347.50755      347.50755      31335.605      31335.605     -24.961039     -24.961039    
     24000  -13445.214     -13445.214     -13531.388     -13531.388      333.50471      333.50471      31297.93       31297.93       3284.25        3284.25      
Loop time of 51.5276 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.313 hours/ns, 19.407 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.441     | 51.441     | 51.441     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019246   | 0.019246   | 0.019246   |   0.0 |  0.04
Output  | 3.181e-05  | 3.181e-05  | 3.181e-05  |   0.0 |  0.00
Modify  | 0.061745   | 0.061745   | 0.061745   |   0.0 |  0.12
Other   |            | 0.006012   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272122 ave      272122 max      272122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272122
Ave neighs/atom = 136.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.155123946825, Press = -3.48865551549015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13445.214     -13445.214     -13531.388     -13531.388      333.50471      333.50471      31297.93       31297.93       3284.25        3284.25      
     25000  -13446.869     -13446.869     -13532.846     -13532.846      332.73971      332.73971      31310.267      31310.267      2004.1112      2004.1112    
Loop time of 51.3184 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.255 hours/ns, 19.486 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.231     | 51.231     | 51.231     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019349   | 0.019349   | 0.019349   |   0.0 |  0.04
Output  | 3.1139e-05 | 3.1139e-05 | 3.1139e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.12
Other   |            | 0.005996   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272144 ave      272144 max      272144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272144
Ave neighs/atom = 136.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.317632519337, Press = -0.516417440155284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13446.869     -13446.869     -13532.846     -13532.846      332.73971      332.73971      31310.267      31310.267      2004.1112      2004.1112    
     26000  -13442.776     -13442.776     -13530.264     -13530.264      338.58778      338.58778      31355.91       31355.91      -1481.9932     -1481.9932    
Loop time of 51.3061 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.252 hours/ns, 19.491 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.219     | 51.219     | 51.219     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019248   | 0.019248   | 0.019248   |   0.0 |  0.04
Output  | 3.3052e-05 | 3.3052e-05 | 3.3052e-05 |   0.0 |  0.00
Modify  | 0.061598   | 0.061598   | 0.061598   |   0.0 |  0.12
Other   |            | 0.006003   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272152 ave      272152 max      272152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272152
Ave neighs/atom = 136.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.343268488749, Press = -1.25947304252903
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13442.776     -13442.776     -13530.264     -13530.264      338.58778      338.58778      31355.91       31355.91      -1481.9932     -1481.9932    
     27000  -13445.721     -13445.721     -13530.985     -13530.985      329.97946      329.97946      31352.979      31352.979     -1351.6562     -1351.6562    
Loop time of 51.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.259 hours/ns, 19.480 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.247     | 51.247     | 51.247     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019255   | 0.019255   | 0.019255   |   0.0 |  0.04
Output  | 3.5107e-05 | 3.5107e-05 | 3.5107e-05 |   0.0 |  0.00
Modify  | 0.061677   | 0.061677   | 0.061677   |   0.0 |  0.12
Other   |            | 0.005953   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272170 ave      272170 max      272170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272170
Ave neighs/atom = 136.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.250301743845, Press = -3.85021921184765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13445.721     -13445.721     -13530.985     -13530.985      329.97946      329.97946      31352.979      31352.979     -1351.6562     -1351.6562    
     28000  -13446.606     -13446.606     -13533.251     -13533.251      335.32355      335.32355      31332.282      31332.282      135.29106      135.29106    
Loop time of 51.4412 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.289 hours/ns, 19.440 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.354     | 51.354     | 51.354     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019215   | 0.019215   | 0.019215   |   0.0 |  0.04
Output  | 3.1169e-05 | 3.1169e-05 | 3.1169e-05 |   0.0 |  0.00
Modify  | 0.061708   | 0.061708   | 0.061708   |   0.0 |  0.12
Other   |            | 0.005967   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272182 ave      272182 max      272182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272182
Ave neighs/atom = 136.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.181553850443, Press = -3.5859598356531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13446.606     -13446.606     -13533.251     -13533.251      335.32355      335.32355      31332.282      31332.282      135.29106      135.29106    
     29000  -13444.707     -13444.707     -13529.643     -13529.643      328.71135      328.71135      31327.101      31327.101      879.34949      879.34949    
Loop time of 51.4236 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.284 hours/ns, 19.446 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.337     | 51.337     | 51.337     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019236   | 0.019236   | 0.019236   |   0.0 |  0.04
Output  | 3.169e-05  | 3.169e-05  | 3.169e-05  |   0.0 |  0.00
Modify  | 0.061656   | 0.061656   | 0.061656   |   0.0 |  0.12
Other   |            | 0.005973   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272114 ave      272114 max      272114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272114
Ave neighs/atom = 136.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.061168879572, Press = -2.509375421996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13444.707     -13444.707     -13529.643     -13529.643      328.71135      328.71135      31327.101      31327.101      879.34949      879.34949    
     30000  -13449.068     -13449.068     -13531.21      -13531.21       317.89697      317.89697      31323.324      31323.324      1000.2544      1000.2544    
Loop time of 51.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.269 hours/ns, 19.467 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.281     | 51.281     | 51.281     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019229   | 0.019229   | 0.019229   |   0.0 |  0.04
Output  | 2.2523e-05 | 2.2523e-05 | 2.2523e-05 |   0.0 |  0.00
Modify  | 0.061687   | 0.061687   | 0.061687   |   0.0 |  0.12
Other   |            | 0.005953   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272138 ave      272138 max      272138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272138
Ave neighs/atom = 136.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.006220851526, Press = -2.19218337145119
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13449.068     -13449.068     -13531.21      -13531.21       317.89697      317.89697      31323.324      31323.324      1000.2544      1000.2544    
     31000  -13444.316     -13444.316     -13531.224     -13531.224      336.34233      336.34233      31336.342      31336.342      83.703549      83.703549    
Loop time of 51.4351 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.288 hours/ns, 19.442 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.348     | 51.348     | 51.348     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019278   | 0.019278   | 0.019278   |   0.0 |  0.04
Output  | 3.187e-05  | 3.187e-05  | 3.187e-05  |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.12
Other   |            | 0.005995   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5449 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272122 ave      272122 max      272122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272122
Ave neighs/atom = 136.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915877977995, Press = -2.71291577226518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13444.316     -13444.316     -13531.224     -13531.224      336.34233      336.34233      31336.342      31336.342      83.703549      83.703549    
     32000  -13443.746     -13443.746     -13530.835     -13530.835      337.04595      337.04595      31336.309      31336.309      34.186679      34.186679    
Loop time of 51.2811 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.685 ns/day, 14.245 hours/ns, 19.500 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.194     | 51.194     | 51.194     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019236   | 0.019236   | 0.019236   |   0.0 |  0.04
Output  | 3.2231e-05 | 3.2231e-05 | 3.2231e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.12
Other   |            | 0.006001   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5457 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272144 ave      272144 max      272144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272144
Ave neighs/atom = 136.072
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.864473563836, Press = -2.47202244380565
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13443.746     -13443.746     -13530.835     -13530.835      337.04595      337.04595      31336.309      31336.309      34.186679      34.186679    
     33000  -13446.32      -13446.32      -13530.953     -13530.953      327.53978      327.53978      31333.833      31333.833      97.69756       97.69756     
Loop time of 51.3589 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.266 hours/ns, 19.471 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.272     | 51.272     | 51.272     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019198   | 0.019198   | 0.019198   |   0.0 |  0.04
Output  | 3.0968e-05 | 3.0968e-05 | 3.0968e-05 |   0.0 |  0.00
Modify  | 0.061573   | 0.061573   | 0.061573   |   0.0 |  0.12
Other   |            | 0.005955   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272152 ave      272152 max      272152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272152
Ave neighs/atom = 136.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.948841138455, Press = -2.68179095644273
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13446.32      -13446.32      -13530.953     -13530.953      327.53978      327.53978      31333.833      31333.833      97.69756       97.69756     
     34000  -13441.413     -13441.413     -13529.189     -13529.189      339.70323      339.70323      31337.948      31337.948      252.83087      252.83087    
Loop time of 51.3806 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.272 hours/ns, 19.463 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.294     | 51.294     | 51.294     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019279   | 0.019279   | 0.019279   |   0.0 |  0.04
Output  | 3.1599e-05 | 3.1599e-05 | 3.1599e-05 |   0.0 |  0.00
Modify  | 0.061631   | 0.061631   | 0.061631   |   0.0 |  0.12
Other   |            | 0.005979   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272172 ave      272172 max      272172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272172
Ave neighs/atom = 136.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.0513234052, Press = -2.50576086293226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13441.413     -13441.413     -13529.189     -13529.189      339.70323      339.70323      31337.948      31337.948      252.83087      252.83087    
     35000  -13445.755     -13445.755     -13531.237     -13531.237      330.82263      330.82263      31333.646      31333.646      10.61696       10.61696     
Loop time of 51.3861 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.274 hours/ns, 19.461 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.299     | 51.299     | 51.299     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019302   | 0.019302   | 0.019302   |   0.0 |  0.04
Output  | 3.1089e-05 | 3.1089e-05 | 3.1089e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.12
Other   |            | 0.005979   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272174 ave      272174 max      272174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272174
Ave neighs/atom = 136.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.091830959733, Press = -2.01989364204797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13445.755     -13445.755     -13531.237     -13531.237      330.82263      330.82263      31333.646      31333.646      10.61696       10.61696     
     36000  -13443.38      -13443.38      -13529.667     -13529.667      333.9375       333.9375       31341.946      31341.946     -396.11389     -396.11389    
Loop time of 51.3266 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.257 hours/ns, 19.483 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.24      | 51.24      | 51.24      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019314   | 0.019314   | 0.019314   |   0.0 |  0.04
Output  | 2.9867e-05 | 2.9867e-05 | 2.9867e-05 |   0.0 |  0.00
Modify  | 0.061559   | 0.061559   | 0.061559   |   0.0 |  0.12
Other   |            | 0.005956   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5453 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272154 ave      272154 max      272154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272154
Ave neighs/atom = 136.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.16962372277, Press = -2.37355263982148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13443.38      -13443.38      -13529.667     -13529.667      333.9375       333.9375       31341.946      31341.946     -396.11389     -396.11389    
     37000  -13446.847     -13446.847     -13532.882     -13532.882      332.96633      332.96633      31338.101      31338.101     -512.51198     -512.51198    
Loop time of 51.4545 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.293 hours/ns, 19.435 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.368     | 51.368     | 51.368     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019208   | 0.019208   | 0.019208   |   0.0 |  0.04
Output  | 2.2462e-05 | 2.2462e-05 | 2.2462e-05 |   0.0 |  0.00
Modify  | 0.061541   | 0.061541   | 0.061541   |   0.0 |  0.12
Other   |            | 0.005939   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272156 ave      272156 max      272156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272156
Ave neighs/atom = 136.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.194451908037, Press = -2.69575595291001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13446.847     -13446.847     -13532.882     -13532.882      332.96633      332.96633      31338.101      31338.101     -512.51198     -512.51198    
     38000  -13448.628     -13448.628     -13533.838     -13533.838      329.77089      329.77089      31327.827      31327.827      423.90929      423.90929    
Loop time of 51.3358 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.260 hours/ns, 19.480 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.249     | 51.249     | 51.249     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019325   | 0.019325   | 0.019325   |   0.0 |  0.04
Output  | 3.1179e-05 | 3.1179e-05 | 3.1179e-05 |   0.0 |  0.00
Modify  | 0.061647   | 0.061647   | 0.061647   |   0.0 |  0.12
Other   |            | 0.005961   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272112 ave      272112 max      272112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272112
Ave neighs/atom = 136.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.236503878251, Press = -2.89665659081742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13448.628     -13448.628     -13533.838     -13533.838      329.77089      329.77089      31327.827      31327.827      423.90929      423.90929    
     39000  -13448.374     -13448.374     -13533.314     -13533.314      328.72703      328.72703      31302.086      31302.086      2513.4866      2513.4866    
Loop time of 51.2568 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.686 ns/day, 14.238 hours/ns, 19.510 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.17      | 51.17      | 51.17      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019226   | 0.019226   | 0.019226   |   0.0 |  0.04
Output  | 3.1038e-05 | 3.1038e-05 | 3.1038e-05 |   0.0 |  0.00
Modify  | 0.061631   | 0.061631   | 0.061631   |   0.0 |  0.12
Other   |            | 0.005971   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5453 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272114 ave      272114 max      272114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272114
Ave neighs/atom = 136.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.195696730385, Press = -2.46972176047668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13448.374     -13448.374     -13533.314     -13533.314      328.72703      328.72703      31302.086      31302.086      2513.4866      2513.4866    
     40000  -13440.247     -13440.247     -13529.64      -13529.64       345.95844      345.95844      31321.468      31321.468      1406.1882      1406.1882    
Loop time of 51.3407 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.261 hours/ns, 19.478 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.254     | 51.254     | 51.254     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019187   | 0.019187   | 0.019187   |   0.0 |  0.04
Output  | 3.0298e-05 | 3.0298e-05 | 3.0298e-05 |   0.0 |  0.00
Modify  | 0.061515   | 0.061515   | 0.061515   |   0.0 |  0.12
Other   |            | 0.005971   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272134 ave      272134 max      272134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272134
Ave neighs/atom = 136.067
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.215989395075, Press = -0.468259176536664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13440.247     -13440.247     -13529.64      -13529.64       345.95844      345.95844      31321.468      31321.468      1406.1882      1406.1882    
     41000  -13446.348     -13446.348     -13531.359     -13531.359      329.00161      329.00161      31368.882      31368.882     -2715.3393     -2715.3393    
Loop time of 51.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.313 hours/ns, 19.407 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.44      | 51.44      | 51.44      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019318   | 0.019318   | 0.019318   |   0.0 |  0.04
Output  | 2.9866e-05 | 2.9866e-05 | 2.9866e-05 |   0.0 |  0.00
Modify  | 0.061812   | 0.061812   | 0.061812   |   0.0 |  0.12
Other   |            | 0.005995   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272174 ave      272174 max      272174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272174
Ave neighs/atom = 136.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.263800303566, Press = -0.728918404182419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13446.348     -13446.348     -13531.359     -13531.359      329.00161      329.00161      31368.882      31368.882     -2715.3393     -2715.3393    
     42000  -13446.034     -13446.034     -13531.537     -13531.537      330.90349      330.90349      31352.752      31352.752     -1408.7352     -1408.7352    
Loop time of 51.362 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.267 hours/ns, 19.470 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.275     | 51.275     | 51.275     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019364   | 0.019364   | 0.019364   |   0.0 |  0.04
Output  | 3.1841e-05 | 3.1841e-05 | 3.1841e-05 |   0.0 |  0.00
Modify  | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.12
Other   |            | 0.005975   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5449 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272148 ave      272148 max      272148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272148
Ave neighs/atom = 136.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.270924601511, Press = -2.43483597694487
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13446.034     -13446.034     -13531.537     -13531.537      330.90349      330.90349      31352.752      31352.752     -1408.7352     -1408.7352    
     43000  -13442.602     -13442.602     -13530.373     -13530.373      339.68303      339.68303      31336.667      31336.667      67.107325      67.107325    
Loop time of 51.5221 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.312 hours/ns, 19.409 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.435     | 51.435     | 51.435     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019248   | 0.019248   | 0.019248   |   0.0 |  0.04
Output  | 3.0908e-05 | 3.0908e-05 | 3.0908e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.12
Other   |            | 0.005973   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5453 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272130 ave      272130 max      272130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272130
Ave neighs/atom = 136.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.279601770966, Press = -2.27802574447167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13442.602     -13442.602     -13530.373     -13530.373      339.68303      339.68303      31336.667      31336.667      67.107325      67.107325    
     44000  -13447.703     -13447.703     -13533.171     -13533.171      330.77225      330.77225      31325.141      31325.141      607.10725      607.10725    
Loop time of 51.5354 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.315 hours/ns, 19.404 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.448     | 51.448     | 51.448     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019247   | 0.019247   | 0.019247   |   0.0 |  0.04
Output  | 2.2783e-05 | 2.2783e-05 | 2.2783e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.12
Other   |            | 0.005969   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5464 ave        5464 max        5464 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272132 ave      272132 max      272132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272132
Ave neighs/atom = 136.066
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.266244639409, Press = -2.16218365087141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13447.703     -13447.703     -13533.171     -13533.171      330.77225      330.77225      31325.141      31325.141      607.10725      607.10725    
     45000  -13446.356     -13446.356     -13531.988     -13531.988      331.40481      331.40481      31324.131      31324.131      858.33306      858.33306    
Loop time of 51.5108 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.309 hours/ns, 19.413 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.424     | 51.424     | 51.424     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019263   | 0.019263   | 0.019263   |   0.0 |  0.04
Output  | 3.0367e-05 | 3.0367e-05 | 3.0367e-05 |   0.0 |  0.00
Modify  | 0.06166    | 0.06166    | 0.06166    |   0.0 |  0.12
Other   |            | 0.005981   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272100 ave      272100 max      272100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272100
Ave neighs/atom = 136.05
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.209339966371, Press = -1.45254934516788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13446.356     -13446.356     -13531.988     -13531.988      331.40481      331.40481      31324.131      31324.131      858.33306      858.33306    
     46000  -13445.468     -13445.468     -13532.141     -13532.141      335.43346      335.43346      31350.3        31350.3       -1312.8941     -1312.8941    
Loop time of 51.426 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.285 hours/ns, 19.445 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.339     | 51.339     | 51.339     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019229   | 0.019229   | 0.019229   |   0.0 |  0.04
Output  | 3.2211e-05 | 3.2211e-05 | 3.2211e-05 |   0.0 |  0.00
Modify  | 0.061631   | 0.061631   | 0.061631   |   0.0 |  0.12
Other   |            | 0.00596    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5471 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272138 ave      272138 max      272138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272138
Ave neighs/atom = 136.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.232914309628, Press = -1.01078552276999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13445.468     -13445.468     -13532.141     -13532.141      335.43346      335.43346      31350.3        31350.3       -1312.8941     -1312.8941    
     47000  -13444.888     -13444.888     -13531.144     -13531.144      333.82099      333.82099      31372.562      31372.562     -3068.4814     -3068.4814    
Loop time of 51.4197 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.283 hours/ns, 19.448 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.333     | 51.333     | 51.333     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019168   | 0.019168   | 0.019168   |   0.0 |  0.04
Output  | 3.162e-05  | 3.162e-05  | 3.162e-05  |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.12
Other   |            | 0.00596    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272160 ave      272160 max      272160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272160
Ave neighs/atom = 136.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.201704421595, Press = -1.98030665384297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13444.888     -13444.888     -13531.144     -13531.144      333.82099      333.82099      31372.562      31372.562     -3068.4814     -3068.4814    
     48000  -13445.828     -13445.828     -13531.16      -13531.16       330.24661      330.24661      31342.758      31342.758     -475.39518     -475.39518    
Loop time of 51.4208 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.284 hours/ns, 19.447 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.334     | 51.334     | 51.334     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019225   | 0.019225   | 0.019225   |   0.0 |  0.04
Output  | 3.2962e-05 | 3.2962e-05 | 3.2962e-05 |   0.0 |  0.00
Modify  | 0.061719   | 0.061719   | 0.061719   |   0.0 |  0.12
Other   |            | 0.005954   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5443 ave        5443 max        5443 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272170 ave      272170 max      272170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272170
Ave neighs/atom = 136.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.192983086443, Press = -3.11076153275806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13445.828     -13445.828     -13531.16      -13531.16       330.24661      330.24661      31342.758      31342.758     -475.39518     -475.39518    
     49000  -13443.264     -13443.264     -13529.558     -13529.558      333.96731      333.96731      31293.349      31293.349      3773.3509      3773.3509    
Loop time of 51.4111 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.281 hours/ns, 19.451 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.324     | 51.324     | 51.324     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019335   | 0.019335   | 0.019335   |   0.0 |  0.04
Output  | 3.1319e-05 | 3.1319e-05 | 3.1319e-05 |   0.0 |  0.00
Modify  | 0.061672   | 0.061672   | 0.061672   |   0.0 |  0.12
Other   |            | 0.005957   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.167698346259, Press = -2.21076291049525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13443.264     -13443.264     -13529.558     -13529.558      333.96731      333.96731      31293.349      31293.349      3773.3509      3773.3509    
     50000  -13446.232     -13446.232     -13532.554     -13532.554      334.07695      334.07695      31295.847      31295.847      3278.6434      3278.6434    
Loop time of 51.4784 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.300 hours/ns, 19.426 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.392     | 51.392     | 51.392     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019234   | 0.019234   | 0.019234   |   0.0 |  0.04
Output  | 3.197e-05  | 3.197e-05  | 3.197e-05  |   0.0 |  0.00
Modify  | 0.061602   | 0.061602   | 0.061602   |   0.0 |  0.12
Other   |            | 0.005993   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5454 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272170 ave      272170 max      272170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272170
Ave neighs/atom = 136.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.168333156408, Press = 0.447899687192876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13446.232     -13446.232     -13532.554     -13532.554      334.07695      334.07695      31295.847      31295.847      3278.6434      3278.6434    
     51000  -13444.32      -13444.32      -13532.043     -13532.043      339.49605      339.49605      31348.481      31348.481     -1070.1884     -1070.1884    
Loop time of 51.5284 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.313 hours/ns, 19.407 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.441     | 51.441     | 51.441     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019261   | 0.019261   | 0.019261   |   0.0 |  0.04
Output  | 2.2443e-05 | 2.2443e-05 | 2.2443e-05 |   0.0 |  0.00
Modify  | 0.061793   | 0.061793   | 0.061793   |   0.0 |  0.12
Other   |            | 0.005984   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.146022632266, Press = -0.841628608441808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13444.32      -13444.32      -13532.043     -13532.043      339.49605      339.49605      31348.481      31348.481     -1070.1884     -1070.1884    
     52000  -13448.674     -13448.674     -13531.331     -13531.331      319.89065      319.89065      31348.45       31348.45      -1290.6957     -1290.6957    
Loop time of 51.3464 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.263 hours/ns, 19.476 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.26      | 51.26      | 51.26      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019283   | 0.019283   | 0.019283   |   0.0 |  0.04
Output  | 5.3801e-05 | 5.3801e-05 | 5.3801e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.12
Other   |            | 0.00598    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5457 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272120 ave      272120 max      272120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272120
Ave neighs/atom = 136.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.102664983811, Press = -1.76557327960677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13448.674     -13448.674     -13531.331     -13531.331      319.89065      319.89065      31348.45       31348.45      -1290.6957     -1290.6957    
     53000  -13442.904     -13442.904     -13528.235     -13528.235      330.23748      330.23748      31336.171      31336.171      313.58533      313.58533    
Loop time of 51.4202 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.283 hours/ns, 19.448 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.333     | 51.333     | 51.333     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019253   | 0.019253   | 0.019253   |   0.0 |  0.04
Output  | 3.198e-05  | 3.198e-05  | 3.198e-05  |   0.0 |  0.00
Modify  | 0.061603   | 0.061603   | 0.061603   |   0.0 |  0.12
Other   |            | 0.005962   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5453 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272158 ave      272158 max      272158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272158
Ave neighs/atom = 136.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.087468981815, Press = -2.31092615985861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13442.904     -13442.904     -13528.235     -13528.235      330.23748      330.23748      31336.171      31336.171      313.58533      313.58533    
     54000  -13446.861     -13446.861     -13532.996     -13532.996      333.35083      333.35083      31294.353      31294.353      3089.1675      3089.1675    
Loop time of 51.4825 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.301 hours/ns, 19.424 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.396     | 51.396     | 51.396     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019212   | 0.019212   | 0.019212   |   0.0 |  0.04
Output  | 3.4145e-05 | 3.4145e-05 | 3.4145e-05 |   0.0 |  0.00
Modify  | 0.061654   | 0.061654   | 0.061654   |   0.0 |  0.12
Other   |            | 0.00597    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272164 ave      272164 max      272164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272164
Ave neighs/atom = 136.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.055369447263, Press = -1.68256449771821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13446.861     -13446.861     -13532.996     -13532.996      333.35083      333.35083      31294.353      31294.353      3089.1675      3089.1675    
     55000  -13443.197     -13443.197     -13531.899     -13531.899      343.28395      343.28395      31303.982      31303.982      2565.8831      2565.8831    
Loop time of 51.4238 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.284 hours/ns, 19.446 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.337     | 51.337     | 51.337     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019249   | 0.019249   | 0.019249   |   0.0 |  0.04
Output  | 4.4744e-05 | 4.4744e-05 | 4.4744e-05 |   0.0 |  0.00
Modify  | 0.061667   | 0.061667   | 0.061667   |   0.0 |  0.12
Other   |            | 0.005982   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272182 ave      272182 max      272182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272182
Ave neighs/atom = 136.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.018627671464, Press = 0.425169391656901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13443.197     -13443.197     -13531.899     -13531.899      343.28395      343.28395      31303.982      31303.982      2565.8831      2565.8831    
     56000  -13448.924     -13448.924     -13534.153     -13534.153      329.8456       329.8456       31353.933      31353.933     -1887.514      -1887.514     
Loop time of 51.4838 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.301 hours/ns, 19.424 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.397     | 51.397     | 51.397     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01931    | 0.01931    | 0.01931    |   0.0 |  0.04
Output  | 3.1911e-05 | 3.1911e-05 | 3.1911e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.12
Other   |            | 0.005979   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5466 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272186 ave      272186 max      272186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272186
Ave neighs/atom = 136.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978926909461, Press = -0.556431708398278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13448.924     -13448.924     -13534.153     -13534.153      329.8456       329.8456       31353.933      31353.933     -1887.514      -1887.514     
     57000  -13444.692     -13444.692     -13531.164     -13531.164      334.65511      334.65511      31363.853      31363.853     -2345.8671     -2345.8671    
Loop time of 51.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.277 hours/ns, 19.456 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.311     | 51.311     | 51.311     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019248   | 0.019248   | 0.019248   |   0.0 |  0.04
Output  | 3.2111e-05 | 3.2111e-05 | 3.2111e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.12
Other   |            | 0.005956   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272104 ave      272104 max      272104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272104
Ave neighs/atom = 136.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.945357436144, Press = -1.82203322654601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13444.692     -13444.692     -13531.164     -13531.164      334.65511      334.65511      31363.853      31363.853     -2345.8671     -2345.8671    
     58000  -13446.921     -13446.921     -13533.597     -13533.597      335.44807      335.44807      31327.015      31327.015      411.52294      411.52294    
Loop time of 51.4859 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.302 hours/ns, 19.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.399     | 51.399     | 51.399     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019203   | 0.019203   | 0.019203   |   0.0 |  0.04
Output  | 2.3284e-05 | 2.3284e-05 | 2.3284e-05 |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.12
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272126 ave      272126 max      272126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272126
Ave neighs/atom = 136.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934648969977, Press = -2.36112215879888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13446.921     -13446.921     -13533.597     -13533.597      335.44807      335.44807      31327.015      31327.015      411.52294      411.52294    
     59000  -13443.169     -13443.169     -13530.513     -13530.513      338.02873      338.02873      31304.141      31304.141      2649.3745      2649.3745    
Loop time of 51.5095 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.308 hours/ns, 19.414 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.423     | 51.423     | 51.423     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019245   | 0.019245   | 0.019245   |   0.0 |  0.04
Output  | 3.3624e-05 | 3.3624e-05 | 3.3624e-05 |   0.0 |  0.00
Modify  | 0.061684   | 0.061684   | 0.061684   |   0.0 |  0.12
Other   |            | 0.005968   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5456 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272086 ave      272086 max      272086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272086
Ave neighs/atom = 136.043
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.950320638017, Press = -1.50618207599168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13443.169     -13443.169     -13530.513     -13530.513      338.02873      338.02873      31304.141      31304.141      2649.3745      2649.3745    
     60000  -13448.755     -13448.755     -13533.933     -13533.933      329.64771      329.64771      31319.284      31319.284      994.87474      994.87474    
Loop time of 51.4353 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.288 hours/ns, 19.442 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.348     | 51.348     | 51.348     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019342   | 0.019342   | 0.019342   |   0.0 |  0.04
Output  | 3.7791e-05 | 3.7791e-05 | 3.7791e-05 |   0.0 |  0.00
Modify  | 0.061734   | 0.061734   | 0.061734   |   0.0 |  0.12
Other   |            | 0.005952   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5460 ave        5460 max        5460 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272126 ave      272126 max      272126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272126
Ave neighs/atom = 136.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932246699069, Press = -0.618160510871321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13448.755     -13448.755     -13533.933     -13533.933      329.64771      329.64771      31319.284      31319.284      994.87474      994.87474    
     61000  -13444.014     -13444.014     -13531.425     -13531.425      338.29065      338.29065      31353.155      31353.155     -1590.331      -1590.331     
Loop time of 51.5066 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.307 hours/ns, 19.415 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.419     | 51.419     | 51.419     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019304   | 0.019304   | 0.019304   |   0.0 |  0.04
Output  | 3.6128e-05 | 3.6128e-05 | 3.6128e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.12
Other   |            | 0.005985   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5462 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272156 ave      272156 max      272156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272156
Ave neighs/atom = 136.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915909993428, Press = -0.903995829233555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13444.014     -13444.014     -13531.425     -13531.425      338.29065      338.29065      31353.155      31353.155     -1590.331      -1590.331     
     62000  -13449.073     -13449.073     -13532.338     -13532.338      322.24423      322.24423      31349.421      31349.421     -1542.9611     -1542.9611    
Loop time of 51.4088 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.280 hours/ns, 19.452 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.322     | 51.322     | 51.322     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019242   | 0.019242   | 0.019242   |   0.0 |  0.04
Output  | 3.154e-05  | 3.154e-05  | 3.154e-05  |   0.0 |  0.00
Modify  | 0.061736   | 0.061736   | 0.061736   |   0.0 |  0.12
Other   |            | 0.00589    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272146 ave      272146 max      272146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272146
Ave neighs/atom = 136.073
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871111625444, Press = -1.72619293152497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13449.073     -13449.073     -13532.338     -13532.338      322.24423      322.24423      31349.421      31349.421     -1542.9611     -1542.9611    
     63000  -13443.652     -13443.652     -13530.511     -13530.511      336.15241      336.15241      31333.084      31333.084      350.66068      350.66068    
Loop time of 51.373 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.270 hours/ns, 19.465 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.286     | 51.286     | 51.286     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019229   | 0.019229   | 0.019229   |   0.0 |  0.04
Output  | 3.7441e-05 | 3.7441e-05 | 3.7441e-05 |   0.0 |  0.00
Modify  | 0.061727   | 0.061727   | 0.061727   |   0.0 |  0.12
Other   |            | 0.005902   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272170 ave      272170 max      272170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272170
Ave neighs/atom = 136.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.835392496797, Press = -1.79763262086327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13443.652     -13443.652     -13530.511     -13530.511      336.15241      336.15241      31333.084      31333.084      350.66068      350.66068    
     64000  -13444.41      -13444.41      -13530.566     -13530.566      333.43332      333.43332      31312.418      31312.418      2060.5782      2060.5782    
Loop time of 51.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.289 hours/ns, 19.440 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.353     | 51.353     | 51.353     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019278   | 0.019278   | 0.019278   |   0.0 |  0.04
Output  | 3.6549e-05 | 3.6549e-05 | 3.6549e-05 |   0.0 |  0.00
Modify  | 0.061692   | 0.061692   | 0.061692   |   0.0 |  0.12
Other   |            | 0.00591    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272112 ave      272112 max      272112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272112
Ave neighs/atom = 136.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.83862386267, Press = -1.25183433056278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13444.41      -13444.41      -13530.566     -13530.566      333.43332      333.43332      31312.418      31312.418      2060.5782      2060.5782    
     65000  -13440.663     -13440.663     -13528.921     -13528.921      341.56987      341.56987      31326.027      31326.027      1244.5235      1244.5235    
Loop time of 51.5424 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.676 ns/day, 14.317 hours/ns, 19.402 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.456     | 51.456     | 51.456     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01924    | 0.01924    | 0.01924    |   0.0 |  0.04
Output  | 2.4216e-05 | 2.4216e-05 | 2.4216e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.12
Other   |            | 0.005887   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272210 ave      272210 max      272210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272210
Ave neighs/atom = 136.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.853057767083, Press = -0.168769618337278
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13440.663     -13440.663     -13528.921     -13528.921      341.56987      341.56987      31326.027      31326.027      1244.5235      1244.5235    
     66000  -13447.33      -13447.33      -13530.072     -13530.072      320.22058      320.22058      31379.639      31379.639     -3553.7728     -3553.7728    
Loop time of 51.3318 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.259 hours/ns, 19.481 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.245     | 51.245     | 51.245     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019298   | 0.019298   | 0.019298   |   0.0 |  0.04
Output  | 4.3963e-05 | 4.3963e-05 | 4.3963e-05 |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.12
Other   |            | 0.0059     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272232 ave      272232 max      272232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272232
Ave neighs/atom = 136.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.890895030866, Press = -0.297114327452451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13447.33      -13447.33      -13530.072     -13530.072      320.22058      320.22058      31379.639      31379.639     -3553.7728     -3553.7728    
     67000  -13441.258     -13441.258     -13530.109     -13530.109      343.8635       343.8635       31370.368      31370.368     -2455.619      -2455.619     
Loop time of 51.3837 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.273 hours/ns, 19.461 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.297     | 51.297     | 51.297     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019143   | 0.019143   | 0.019143   |   0.0 |  0.04
Output  | 4.3272e-05 | 4.3272e-05 | 4.3272e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.12
Other   |            | 0.005918   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272130 ave      272130 max      272130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272130
Ave neighs/atom = 136.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.938058051762, Press = -1.67368551800593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13441.258     -13441.258     -13530.109     -13530.109      343.8635       343.8635       31370.368      31370.368     -2455.619      -2455.619     
     68000  -13448.216     -13448.216     -13533.341     -13533.341      329.44244      329.44244      31322.574      31322.574      888.08274      888.08274    
Loop time of 51.2977 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.249 hours/ns, 19.494 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.211     | 51.211     | 51.211     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019166   | 0.019166   | 0.019166   |   0.0 |  0.04
Output  | 3.3493e-05 | 3.3493e-05 | 3.3493e-05 |   0.0 |  0.00
Modify  | 0.061707   | 0.061707   | 0.061707   |   0.0 |  0.12
Other   |            | 0.005958   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968988699419, Press = -1.68365326952134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13448.216     -13448.216     -13533.341     -13533.341      329.44244      329.44244      31322.574      31322.574      888.08274      888.08274    
     69000  -13444.98      -13444.98      -13529.603     -13529.603      327.50201      327.50201      31312.953      31312.953      2158.8105      2158.8105    
Loop time of 51.3715 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.270 hours/ns, 19.466 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.285     | 51.285     | 51.285     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01912    | 0.01912    | 0.01912    |   0.0 |  0.04
Output  | 3.3313e-05 | 3.3313e-05 | 3.3313e-05 |   0.0 |  0.00
Modify  | 0.061651   | 0.061651   | 0.061651   |   0.0 |  0.12
Other   |            | 0.005939   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272168 ave      272168 max      272168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272168
Ave neighs/atom = 136.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9308018095, Press = -1.06230093668548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13444.98      -13444.98      -13529.603     -13529.603      327.50201      327.50201      31312.953      31312.953      2158.8105      2158.8105    
     70000  -13448.48      -13448.48      -13533.652     -13533.652      329.62668      329.62668      31320.975      31320.975      1057.4868      1057.4868    
Loop time of 51.244 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.686 ns/day, 14.234 hours/ns, 19.514 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.157     | 51.157     | 51.157     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019115   | 0.019115   | 0.019115   |   0.0 |  0.04
Output  | 3.3873e-05 | 3.3873e-05 | 3.3873e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.12
Other   |            | 0.006015   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5449 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272210 ave      272210 max      272210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272210
Ave neighs/atom = 136.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.916068915948, Press = -0.616232526789592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13448.48      -13448.48      -13533.652     -13533.652      329.62668      329.62668      31320.975      31320.975      1057.4868      1057.4868    
     71000  -13445.564     -13445.564     -13532.482     -13532.482      336.38512      336.38512      31378.245      31378.245     -3696.4188     -3696.4188    
Loop time of 51.3195 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.255 hours/ns, 19.486 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.233     | 51.233     | 51.233     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019218   | 0.019218   | 0.019218   |   0.0 |  0.04
Output  | 4.1088e-05 | 4.1088e-05 | 4.1088e-05 |   0.0 |  0.00
Modify  | 0.061711   | 0.061711   | 0.061711   |   0.0 |  0.12
Other   |            | 0.005934   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272170 ave      272170 max      272170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272170
Ave neighs/atom = 136.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.957228484132, Press = -0.630533074742177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13445.564     -13445.564     -13532.482     -13532.482      336.38512      336.38512      31378.245      31378.245     -3696.4188     -3696.4188    
     72000  -13443.414     -13443.414     -13531.406     -13531.406      340.53866      340.53866      31383.031      31383.031     -3931.6312     -3931.6312    
Loop time of 51.3389 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.261 hours/ns, 19.478 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.252     | 51.252     | 51.252     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01913    | 0.01913    | 0.01913    |   0.0 |  0.04
Output  | 2.2933e-05 | 2.2933e-05 | 2.2933e-05 |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.12
Other   |            | 0.00591    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5447 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272120 ave      272120 max      272120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272120
Ave neighs/atom = 136.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.977406848791, Press = -1.98491662286022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13443.414     -13443.414     -13531.406     -13531.406      340.53866      340.53866      31383.031      31383.031     -3931.6312     -3931.6312    
     73000  -13446.681     -13446.681     -13531.025     -13531.025      326.42035      326.42035      31328.291      31328.291      733.28739      733.28739    
Loop time of 51.3248 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.257 hours/ns, 19.484 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.238     | 51.238     | 51.238     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019149   | 0.019149   | 0.019149   |   0.0 |  0.04
Output  | 3.1769e-05 | 3.1769e-05 | 3.1769e-05 |   0.0 |  0.00
Modify  | 0.061637   | 0.061637   | 0.061637   |   0.0 |  0.12
Other   |            | 0.005922   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.029889031569, Press = -1.45833638539199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13446.681     -13446.681     -13531.025     -13531.025      326.42035      326.42035      31328.291      31328.291      733.28739      733.28739    
     74000  -13443.986     -13443.986     -13529.076     -13529.076      329.30848      329.30848      31323.853      31323.853      1216.6063      1216.6063    
Loop time of 51.4519 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.292 hours/ns, 19.436 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.365     | 51.365     | 51.365     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019264   | 0.019264   | 0.019264   |   0.0 |  0.04
Output  | 3.2391e-05 | 3.2391e-05 | 3.2391e-05 |   0.0 |  0.00
Modify  | 0.061742   | 0.061742   | 0.061742   |   0.0 |  0.12
Other   |            | 0.005912   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5454 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272166 ave      272166 max      272166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272166
Ave neighs/atom = 136.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.038986136972, Press = -1.05157866461006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13443.986     -13443.986     -13529.076     -13529.076      329.30848      329.30848      31323.853      31323.853      1216.6063      1216.6063    
     75000  -13445.465     -13445.465     -13530.75      -13530.75       330.06165      330.06165      31327.604      31327.604      840.95135      840.95135    
Loop time of 51.4217 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.284 hours/ns, 19.447 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.335     | 51.335     | 51.335     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019151   | 0.019151   | 0.019151   |   0.0 |  0.04
Output  | 3.0968e-05 | 3.0968e-05 | 3.0968e-05 |   0.0 |  0.00
Modify  | 0.061704   | 0.061704   | 0.061704   |   0.0 |  0.12
Other   |            | 0.005927   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272172 ave      272172 max      272172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272172
Ave neighs/atom = 136.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.000356702247, Press = -0.631429413452027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13445.465     -13445.465     -13530.75      -13530.75       330.06165      330.06165      31327.604      31327.604      840.95135      840.95135    
     76000  -13449.514     -13449.514     -13534.176     -13534.176      327.65087      327.65087      31358.445      31358.445     -2200.3379     -2200.3379    
Loop time of 51.3353 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.260 hours/ns, 19.480 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.248     | 51.248     | 51.248     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019198   | 0.019198   | 0.019198   |   0.0 |  0.04
Output  | 3.1269e-05 | 3.1269e-05 | 3.1269e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.12
Other   |            | 0.005938   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5454 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272128 ave      272128 max      272128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272128
Ave neighs/atom = 136.064
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.98087994667, Press = -0.641194433994719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13449.514     -13449.514     -13534.176     -13534.176      327.65087      327.65087      31358.445      31358.445     -2200.3379     -2200.3379    
     77000  -13443.574     -13443.574     -13530.564     -13530.564      336.65816      336.65816      31369.269      31369.269     -2684.835      -2684.835     
Loop time of 51.2154 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.687 ns/day, 14.227 hours/ns, 19.525 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.129     | 51.129     | 51.129     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019223   | 0.019223   | 0.019223   |   0.0 |  0.04
Output  | 3.1129e-05 | 3.1129e-05 | 3.1129e-05 |   0.0 |  0.00
Modify  | 0.061671   | 0.061671   | 0.061671   |   0.0 |  0.12
Other   |            | 0.005935   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5464 ave        5464 max        5464 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272154 ave      272154 max      272154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272154
Ave neighs/atom = 136.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945957414167, Press = -1.76402166992817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13443.574     -13443.574     -13530.564     -13530.564      336.65816      336.65816      31369.269      31369.269     -2684.835      -2684.835     
     78000  -13449.038     -13449.038     -13533.675     -13533.675      327.55262      327.55262      31316.362      31316.362      1240.3209      1240.3209    
Loop time of 51.2717 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.685 ns/day, 14.242 hours/ns, 19.504 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.185     | 51.185     | 51.185     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01919    | 0.01919    | 0.01919    |   0.0 |  0.04
Output  | 3.0418e-05 | 3.0418e-05 | 3.0418e-05 |   0.0 |  0.00
Modify  | 0.06177    | 0.06177    | 0.06177    |   0.0 |  0.12
Other   |            | 0.005935   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272140 ave      272140 max      272140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272140
Ave neighs/atom = 136.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9162964305, Press = -1.71438341152649
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13449.038     -13449.038     -13533.675     -13533.675      327.55262      327.55262      31316.362      31316.362      1240.3209      1240.3209    
     79000  -13443.931     -13443.931     -13530.115     -13530.115      333.53949      333.53949      31306.219      31306.219      2806.3781      2806.3781    
Loop time of 51.3766 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.271 hours/ns, 19.464 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.29      | 51.29      | 51.29      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019205   | 0.019205   | 0.019205   |   0.0 |  0.04
Output  | 2.3274e-05 | 2.3274e-05 | 2.3274e-05 |   0.0 |  0.00
Modify  | 0.061639   | 0.061639   | 0.061639   |   0.0 |  0.12
Other   |            | 0.005885   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5450 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.916445084538, Press = -0.918457363677271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13443.931     -13443.931     -13530.115     -13530.115      333.53949      333.53949      31306.219      31306.219      2806.3781      2806.3781    
     80000  -13443.488     -13443.488     -13531.404     -13531.404      340.24215      340.24215      31328.371      31328.371      646.67951      646.67951    
Loop time of 51.4974 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.305 hours/ns, 19.418 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.411     | 51.411     | 51.411     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019092   | 0.019092   | 0.019092   |   0.0 |  0.04
Output  | 3.175e-05  | 3.175e-05  | 3.175e-05  |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.12
Other   |            | 0.005918   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272162 ave      272162 max      272162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272162
Ave neighs/atom = 136.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.908049194658, Press = -0.48970490578495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13443.488     -13443.488     -13531.404     -13531.404      340.24215      340.24215      31328.371      31328.371      646.67951      646.67951    
     81000  -13446.004     -13446.004     -13532.173     -13532.173      333.48414      333.48414      31355.357      31355.357     -1712.6809     -1712.6809    
Loop time of 51.3481 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.263 hours/ns, 19.475 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.261     | 51.261     | 51.261     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01913    | 0.01913    | 0.01913    |   0.0 |  0.04
Output  | 3.5456e-05 | 3.5456e-05 | 3.5456e-05 |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.12
Other   |            | 0.005939   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272164 ave      272164 max      272164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272164
Ave neighs/atom = 136.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.943783825283, Press = -0.701946668791425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13446.004     -13446.004     -13532.173     -13532.173      333.48414      333.48414      31355.357      31355.357     -1712.6809     -1712.6809    
     82000  -13441.747     -13441.747     -13531.018     -13531.018      345.48868      345.48868      31374.474      31374.474     -3241.7365     -3241.7365    
Loop time of 51.3879 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.274 hours/ns, 19.460 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.301     | 51.301     | 51.301     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019147   | 0.019147   | 0.019147   |   0.0 |  0.04
Output  | 3.0598e-05 | 3.0598e-05 | 3.0598e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.12
Other   |            | 0.005929   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272124 ave      272124 max      272124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272124
Ave neighs/atom = 136.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.961438543698, Press = -1.58052710698701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13441.747     -13441.747     -13531.018     -13531.018      345.48868      345.48868      31374.474      31374.474     -3241.7365     -3241.7365    
     83000  -13445.118     -13445.118     -13531.035     -13531.035      332.5087       332.5087       31321.098      31321.098      1320.0003      1320.0003    
Loop time of 51.4924 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.303 hours/ns, 19.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.405     | 51.405     | 51.405     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019231   | 0.019231   | 0.019231   |   0.0 |  0.04
Output  | 3.1429e-05 | 3.1429e-05 | 3.1429e-05 |   0.0 |  0.00
Modify  | 0.061716   | 0.061716   | 0.061716   |   0.0 |  0.12
Other   |            | 0.005932   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272116 ave      272116 max      272116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272116
Ave neighs/atom = 136.058
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.948391336088, Press = -1.87305055471968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13445.118     -13445.118     -13531.035     -13531.035      332.5087       332.5087       31321.098      31321.098      1320.0003      1320.0003    
     84000  -13446.518     -13446.518     -13531.79      -13531.79       330.01386      330.01386      31305.544      31305.544      2403.0056      2403.0056    
Loop time of 51.2999 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.250 hours/ns, 19.493 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.213     | 51.213     | 51.213     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019217   | 0.019217   | 0.019217   |   0.0 |  0.04
Output  | 3.229e-05  | 3.229e-05  | 3.229e-05  |   0.0 |  0.00
Modify  | 0.061725   | 0.061725   | 0.061725   |   0.0 |  0.12
Other   |            | 0.005915   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5458 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272160 ave      272160 max      272160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272160
Ave neighs/atom = 136.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.940532072754, Press = -0.825939350393294
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13446.518     -13446.518     -13531.79      -13531.79       330.01386      330.01386      31305.544      31305.544      2403.0056      2403.0056    
     85000  -13443.363     -13443.363     -13532.152     -13532.152      343.62373      343.62373      31332.444      31332.444      95.123279      95.123279    
Loop time of 51.3267 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.257 hours/ns, 19.483 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.24      | 51.24      | 51.24      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019244   | 0.019244   | 0.019244   |   0.0 |  0.04
Output  | 3.0788e-05 | 3.0788e-05 | 3.0788e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.12
Other   |            | 0.005912   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5465 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272150 ave      272150 max      272150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272150
Ave neighs/atom = 136.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941209196914, Press = -0.437196265436022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13443.363     -13443.363     -13532.152     -13532.152      343.62373      343.62373      31332.444      31332.444      95.123279      95.123279    
     86000  -13448.4       -13448.4       -13532.29      -13532.29       324.65981      324.65981      31349.465      31349.465     -1371.6475     -1371.6475    
Loop time of 51.3921 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.276 hours/ns, 19.458 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.305     | 51.305     | 51.305     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019197   | 0.019197   | 0.019197   |   0.0 |  0.04
Output  | 2.3054e-05 | 2.3054e-05 | 2.3054e-05 |   0.0 |  0.00
Modify  | 0.061698   | 0.061698   | 0.061698   |   0.0 |  0.12
Other   |            | 0.005944   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5462 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272160 ave      272160 max      272160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272160
Ave neighs/atom = 136.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.938973135511, Press = -0.719960533013065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13448.4       -13448.4       -13532.29      -13532.29       324.65981      324.65981      31349.465      31349.465     -1371.6475     -1371.6475    
     87000  -13444.14      -13444.14      -13529.02      -13529.02       328.49485      328.49485      31360.775      31360.775     -1938.8633     -1938.8633    
Loop time of 51.4637 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.295 hours/ns, 19.431 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.377     | 51.377     | 51.377     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019159   | 0.019159   | 0.019159   |   0.0 |  0.04
Output  | 3.3293e-05 | 3.3293e-05 | 3.3293e-05 |   0.0 |  0.00
Modify  | 0.061717   | 0.061717   | 0.061717   |   0.0 |  0.12
Other   |            | 0.005943   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272140 ave      272140 max      272140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272140
Ave neighs/atom = 136.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.917293754071, Press = -1.43942092543842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13444.14      -13444.14      -13529.02      -13529.02       328.49485      328.49485      31360.775      31360.775     -1938.8633     -1938.8633    
     88000  -13449.362     -13449.362     -13535.864     -13535.864      334.77037      334.77037      31303.857      31303.857      1982.7426      1982.7426    
Loop time of 51.2592 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.686 ns/day, 14.239 hours/ns, 19.509 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.172     | 51.172     | 51.172     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019152   | 0.019152   | 0.019152   |   0.0 |  0.04
Output  | 3.206e-05  | 3.206e-05  | 3.206e-05  |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.12
Other   |            | 0.005933   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5452 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272168 ave      272168 max      272168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272168
Ave neighs/atom = 136.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.893629587203, Press = -2.01600068740396
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13449.362     -13449.362     -13535.864     -13535.864      334.77037      334.77037      31303.857      31303.857      1982.7426      1982.7426    
     89000  -13444.048     -13444.048     -13532.148     -13532.148      340.9572       340.9572       31296.494      31296.494      3016.3146      3016.3146    
Loop time of 51.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.265 hours/ns, 19.472 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.268     | 51.268     | 51.268     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019148   | 0.019148   | 0.019148   |   0.0 |  0.04
Output  | 3.7461e-05 | 3.7461e-05 | 3.7461e-05 |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.12
Other   |            | 0.005931   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5447 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272108 ave      272108 max      272108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272108
Ave neighs/atom = 136.054
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.876976010351, Press = -0.579223477338551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13444.048     -13444.048     -13532.148     -13532.148      340.9572       340.9572       31296.494      31296.494      3016.3146      3016.3146    
     90000  -13441.443     -13441.443     -13529.343     -13529.343      340.18279      340.18279      31329.364      31329.364      877.15451      877.15451    
Loop time of 51.3305 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.258 hours/ns, 19.482 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.244     | 51.244     | 51.244     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019169   | 0.019169   | 0.019169   |   0.0 |  0.04
Output  | 3.4896e-05 | 3.4896e-05 | 3.4896e-05 |   0.0 |  0.00
Modify  | 0.061672   | 0.061672   | 0.061672   |   0.0 |  0.12
Other   |            | 0.005925   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5467 ave        5467 max        5467 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272176 ave      272176 max      272176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272176
Ave neighs/atom = 136.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.874047499294, Press = -0.267505399025948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -13441.443     -13441.443     -13529.343     -13529.343      340.18279      340.18279      31329.364      31329.364      877.15451      877.15451    
     91000  -13446.56      -13446.56      -13532.043     -13532.043      330.82483      330.82483      31348.595      31348.595     -1220.8142     -1220.8142    
Loop time of 51.5251 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.313 hours/ns, 19.408 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.438     | 51.438     | 51.438     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019285   | 0.019285   | 0.019285   |   0.0 |  0.04
Output  | 3.192e-05  | 3.192e-05  | 3.192e-05  |   0.0 |  0.00
Modify  | 0.061743   | 0.061743   | 0.061743   |   0.0 |  0.12
Other   |            | 0.005927   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5462 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272182 ave      272182 max      272182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272182
Ave neighs/atom = 136.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.909908390685, Press = -0.583635413376831
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -13446.56      -13446.56      -13532.043     -13532.043      330.82483      330.82483      31348.595      31348.595     -1220.8142     -1220.8142    
     92000  -13439.191     -13439.191     -13528.742     -13528.742      346.57338      346.57338      31359.71       31359.71      -1662.0127     -1662.0127    
Loop time of 51.3551 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.265 hours/ns, 19.472 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.268     | 51.268     | 51.268     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019299   | 0.019299   | 0.019299   |   0.0 |  0.04
Output  | 2.9225e-05 | 2.9225e-05 | 2.9225e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.12
Other   |            | 0.005898   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5461 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272114 ave      272114 max      272114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272114
Ave neighs/atom = 136.057
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.933195042163, Press = -1.1098331882747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -13439.191     -13439.191     -13528.742     -13528.742      346.57338      346.57338      31359.71       31359.71      -1662.0127     -1662.0127    
     93000  -13447.121     -13447.121     -13533.45      -13533.45       334.10328      334.10328      31303.989      31303.989      2216.413       2216.413     
Loop time of 51.3775 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.272 hours/ns, 19.464 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.291     | 51.291     | 51.291     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019147   | 0.019147   | 0.019147   |   0.0 |  0.04
Output  | 2.2442e-05 | 2.2442e-05 | 2.2442e-05 |   0.0 |  0.00
Modify  | 0.061693   | 0.061693   | 0.061693   |   0.0 |  0.12
Other   |            | 0.005925   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272194 ave      272194 max      272194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272194
Ave neighs/atom = 136.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.95224961658, Press = -1.60350791702852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -13447.121     -13447.121     -13533.45      -13533.45       334.10328      334.10328      31303.989      31303.989      2216.413       2216.413     
     94000  -13448.456     -13448.456     -13534.249     -13534.249      332.02771      332.02771      31267.519      31267.519      5096.3822      5096.3822    
Loop time of 51.3714 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.270 hours/ns, 19.466 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.285     | 51.285     | 51.285     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019219   | 0.019219   | 0.019219   |   0.0 |  0.04
Output  | 3.2301e-05 | 3.2301e-05 | 3.2301e-05 |   0.0 |  0.00
Modify  | 0.061659   | 0.061659   | 0.061659   |   0.0 |  0.12
Other   |            | 0.005948   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5466 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949024460337, Press = -0.445266235538578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -13448.456     -13448.456     -13534.249     -13534.249      332.02771      332.02771      31267.519      31267.519      5096.3822      5096.3822    
     95000  -13444.917     -13444.917     -13530.97      -13530.97       333.03472      333.03472      31333.987      31333.987      189.22092      189.22092    
Loop time of 51.4157 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.282 hours/ns, 19.449 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.329     | 51.329     | 51.329     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019206   | 0.019206   | 0.019206   |   0.0 |  0.04
Output  | 3.4495e-05 | 3.4495e-05 | 3.4495e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.12
Other   |            | 0.005924   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5466 ave        5466 max        5466 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272204 ave      272204 max      272204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272204
Ave neighs/atom = 136.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.914822487281, Press = 0.0617219862323538
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -13444.917     -13444.917     -13530.97      -13530.97       333.03472      333.03472      31333.987      31333.987      189.22092      189.22092    
     96000  -13450.547     -13450.547     -13534.371     -13534.371      324.40832      324.40832      31359.201      31359.201     -2388.3161     -2388.3161    
Loop time of 51.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.276 hours/ns, 19.457 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.308     | 51.308     | 51.308     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019247   | 0.019247   | 0.019247   |   0.0 |  0.04
Output  | 3.1279e-05 | 3.1279e-05 | 3.1279e-05 |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.12
Other   |            | 0.00593    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5468 ave        5468 max        5468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272140 ave      272140 max      272140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272140
Ave neighs/atom = 136.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897392831969, Press = -0.62715926640811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -13450.547     -13450.547     -13534.371     -13534.371      324.40832      324.40832      31359.201      31359.201     -2388.3161     -2388.3161    
     97000  -13446.036     -13446.036     -13532.432     -13532.432      334.36163      334.36163      31350.248      31350.248     -1394.7079     -1394.7079    
Loop time of 51.3592 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.266 hours/ns, 19.471 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.272     | 51.272     | 51.272     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019153   | 0.019153   | 0.019153   |   0.0 |  0.04
Output  | 3.226e-05  | 3.226e-05  | 3.226e-05  |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.12
Other   |            | 0.005941   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5452 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272130 ave      272130 max      272130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272130
Ave neighs/atom = 136.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.891921457679, Press = -1.06926043003132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -13446.036     -13446.036     -13532.432     -13532.432      334.36163      334.36163      31350.248      31350.248     -1394.7079     -1394.7079    
     98000  -13446.895     -13446.895     -13532.398     -13532.398      330.90501      330.90501      31316.97       31316.97       1339.6025      1339.6025    
Loop time of 51.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.303 hours/ns, 19.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.403     | 51.403     | 51.403     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01918    | 0.01918    | 0.01918    |   0.0 |  0.04
Output  | 3.3694e-05 | 3.3694e-05 | 3.3694e-05 |   0.0 |  0.00
Modify  | 0.061724   | 0.061724   | 0.061724   |   0.0 |  0.12
Other   |            | 0.005942   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272138 ave      272138 max      272138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272138
Ave neighs/atom = 136.069
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888807141241, Press = -0.967317875533303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -13446.895     -13446.895     -13532.398     -13532.398      330.90501      330.90501      31316.97       31316.97       1339.6025      1339.6025    
     99000  -13443.868     -13443.868     -13529.927     -13529.927      333.05626      333.05626      31298.423      31298.423      3258.8847      3258.8847    
Loop time of 51.3077 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.252 hours/ns, 19.490 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.221     | 51.221     | 51.221     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019142   | 0.019142   | 0.019142   |   0.0 |  0.04
Output  | 2.9886e-05 | 2.9886e-05 | 2.9886e-05 |   0.0 |  0.00
Modify  | 0.061673   | 0.061673   | 0.061673   |   0.0 |  0.12
Other   |            | 0.00594    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5454 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880530956874, Press = -0.423957507707614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -13443.868     -13443.868     -13529.927     -13529.927      333.05626      333.05626      31298.423      31298.423      3258.8847      3258.8847    
    100000  -13447.469     -13447.469     -13532.171     -13532.171      327.80537      327.80537      31328.568      31328.568      389.50011      389.50011    
Loop time of 51.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.271 hours/ns, 19.464 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.289     | 51.289     | 51.289     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019298   | 0.019298   | 0.019298   |   0.0 |  0.04
Output  | 2.3254e-05 | 2.3254e-05 | 2.3254e-05 |   0.0 |  0.00
Modify  | 0.061751   | 0.061751   | 0.061751   |   0.0 |  0.12
Other   |            | 0.005942   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5468 ave        5468 max        5468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272176 ave      272176 max      272176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272176
Ave neighs/atom = 136.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.889713660913, Press = 0.169480223237416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -13447.469     -13447.469     -13532.171     -13532.171      327.80537      327.80537      31328.568      31328.568      389.50011      389.50011    
    101000  -13445.816     -13445.816     -13532.034     -13532.034      333.67198      333.67198      31368.19       31368.19      -2907.2016     -2907.2016    
Loop time of 51.3486 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.264 hours/ns, 19.475 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.262     | 51.262     | 51.262     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019178   | 0.019178   | 0.019178   |   0.0 |  0.04
Output  | 3.2552e-05 | 3.2552e-05 | 3.2552e-05 |   0.0 |  0.00
Modify  | 0.061733   | 0.061733   | 0.061733   |   0.0 |  0.12
Other   |            | 0.005936   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5448 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272176 ave      272176 max      272176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272176
Ave neighs/atom = 136.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.860808179, Press = -0.449160734612401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -13445.816     -13445.816     -13532.034     -13532.034      333.67198      333.67198      31368.19       31368.19      -2907.2016     -2907.2016    
    102000  -13445.808     -13445.808     -13531.968     -13531.968      333.45094      333.45094      31344.721      31344.721     -906.57222     -906.57222    
Loop time of 51.3706 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.270 hours/ns, 19.466 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.284     | 51.284     | 51.284     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019186   | 0.019186   | 0.019186   |   0.0 |  0.04
Output  | 3.2542e-05 | 3.2542e-05 | 3.2542e-05 |   0.0 |  0.00
Modify  | 0.061706   | 0.061706   | 0.061706   |   0.0 |  0.12
Other   |            | 0.005936   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272118 ave      272118 max      272118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272118
Ave neighs/atom = 136.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.867022806857, Press = -0.869944610909832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -13445.808     -13445.808     -13531.968     -13531.968      333.45094      333.45094      31344.721      31344.721     -906.57222     -906.57222    
    103000  -13445.846     -13445.846     -13534.77      -13534.77       344.14659      344.14659      31331.716      31331.716     -171.13817     -171.13817    
Loop time of 51.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.289 hours/ns, 19.441 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.352     | 51.352     | 51.352     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019163   | 0.019163   | 0.019163   |   0.0 |  0.04
Output  | 3.0267e-05 | 3.0267e-05 | 3.0267e-05 |   0.0 |  0.00
Modify  | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.12
Other   |            | 0.005927   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5451 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272148 ave      272148 max      272148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272148
Ave neighs/atom = 136.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883636718386, Press = -0.85615537906729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -13445.846     -13445.846     -13534.77      -13534.77       344.14659      344.14659      31331.716      31331.716     -171.13817     -171.13817    
    104000  -13447.8       -13447.8       -13533.1       -13533.1        330.11849      330.11849      31317.925      31317.925      1191.105       1191.105     
Loop time of 51.3961 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.277 hours/ns, 19.457 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.309     | 51.309     | 51.309     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019118   | 0.019118   | 0.019118   |   0.0 |  0.04
Output  | 3.4896e-05 | 3.4896e-05 | 3.4896e-05 |   0.0 |  0.00
Modify  | 0.061713   | 0.061713   | 0.061713   |   0.0 |  0.12
Other   |            | 0.005931   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272108 ave      272108 max      272108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272108
Ave neighs/atom = 136.054
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905649422988, Press = -0.604951264488306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -13447.8       -13447.8       -13533.1       -13533.1        330.11849      330.11849      31317.925      31317.925      1191.105       1191.105     
    105000  -13440.567     -13440.567     -13530.182     -13530.182      346.81825      346.81825      31333.085      31333.085      338.50769      338.50769    
Loop time of 51.3306 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.683 ns/day, 14.258 hours/ns, 19.482 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.244     | 51.244     | 51.244     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019138   | 0.019138   | 0.019138   |   0.0 |  0.04
Output  | 3.0397e-05 | 3.0397e-05 | 3.0397e-05 |   0.0 |  0.00
Modify  | 0.061747   | 0.061747   | 0.061747   |   0.0 |  0.12
Other   |            | 0.005948   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272112 ave      272112 max      272112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272112
Ave neighs/atom = 136.056
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923111033512, Press = -0.0812154292609596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -13440.567     -13440.567     -13530.182     -13530.182      346.81825      346.81825      31333.085      31333.085      338.50769      338.50769    
    106000  -13446.092     -13446.092     -13533.663     -13533.663      338.90874      338.90874      31379.148      31379.148     -3926.6674     -3926.6674    
Loop time of 51.4332 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.287 hours/ns, 19.443 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.346     | 51.346     | 51.346     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019155   | 0.019155   | 0.019155   |   0.0 |  0.04
Output  | 3.0037e-05 | 3.0037e-05 | 3.0037e-05 |   0.0 |  0.00
Modify  | 0.061701   | 0.061701   | 0.061701   |   0.0 |  0.12
Other   |            | 0.005937   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5468 ave        5468 max        5468 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272168 ave      272168 max      272168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272168
Ave neighs/atom = 136.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.94630594352, Press = -0.427827658822905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -13446.092     -13446.092     -13533.663     -13533.663      338.90874      338.90874      31379.148      31379.148     -3926.6674     -3926.6674    
    107000  -13438.85      -13438.85      -13526.981     -13526.981      341.07651      341.07651      31366.553      31366.553     -1828.8729     -1828.8729    
Loop time of 51.4341 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.287 hours/ns, 19.442 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.347     | 51.347     | 51.347     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019177   | 0.019177   | 0.019177   |   0.0 |  0.04
Output  | 2.2893e-05 | 2.2893e-05 | 2.2893e-05 |   0.0 |  0.00
Modify  | 0.061589   | 0.061589   | 0.061589   |   0.0 |  0.12
Other   |            | 0.005917   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5459 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272136 ave      272136 max      272136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272136
Ave neighs/atom = 136.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.97355682201, Press = -1.05080834102773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -13438.85      -13438.85      -13526.981     -13526.981      341.07651      341.07651      31366.553      31366.553     -1828.8729     -1828.8729    
    108000  -13445.916     -13445.916     -13531.384     -13531.384      330.7696       330.7696       31323.552      31323.552      879.16128      879.16128    
Loop time of 51.4938 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.678 ns/day, 14.304 hours/ns, 19.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.407     | 51.407     | 51.407     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01913    | 0.01913    | 0.01913    |   0.0 |  0.04
Output  | 3.1118e-05 | 3.1118e-05 | 3.1118e-05 |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.12
Other   |            | 0.005951   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5455 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272140 ave      272140 max      272140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272140
Ave neighs/atom = 136.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.995568165647, Press = -0.895532987741963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -13445.916     -13445.916     -13531.384     -13531.384      330.7696       330.7696       31323.552      31323.552      879.16128      879.16128    
    109000  -13445.043     -13445.043     -13531.117     -13531.117      333.11754      333.11754      31322.167      31322.167      951.4818       951.4818     
Loop time of 51.3182 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.684 ns/day, 14.255 hours/ns, 19.486 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.232     | 51.232     | 51.232     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019131   | 0.019131   | 0.019131   |   0.0 |  0.04
Output  | 3.171e-05  | 3.171e-05  | 3.171e-05  |   0.0 |  0.00
Modify  | 0.061653   | 0.061653   | 0.061653   |   0.0 |  0.12
Other   |            | 0.005917   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5467 ave        5467 max        5467 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272188 ave      272188 max      272188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272188
Ave neighs/atom = 136.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.000258376188, Press = -0.476705807758808
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -13445.043     -13445.043     -13531.117     -13531.117      333.11754      333.11754      31322.167      31322.167      951.4818       951.4818     
    110000  -13449.853     -13449.853     -13532.571     -13532.571      320.129        320.129        31333.291      31333.291     -268.92657     -268.92657    
Loop time of 51.3691 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.682 ns/day, 14.269 hours/ns, 19.467 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.282     | 51.282     | 51.282     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019163   | 0.019163   | 0.019163   |   0.0 |  0.04
Output  | 3.206e-05  | 3.206e-05  | 3.206e-05  |   0.0 |  0.00
Modify  | 0.061715   | 0.061715   | 0.061715   |   0.0 |  0.12
Other   |            | 0.005949   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5462 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272216 ave      272216 max      272216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272216
Ave neighs/atom = 136.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.988310840804, Press = -0.50044430432038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -13449.853     -13449.853     -13532.571     -13532.571      320.129        320.129        31333.291      31333.291     -268.92657     -268.92657    
    111000  -13444.743     -13444.743     -13530.183     -13530.183      330.6595       330.6595       31350.414      31350.414     -1201.0571     -1201.0571    
Loop time of 51.4278 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.680 ns/day, 14.286 hours/ns, 19.445 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.341     | 51.341     | 51.341     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019152   | 0.019152   | 0.019152   |   0.0 |  0.04
Output  | 2.9906e-05 | 2.9906e-05 | 2.9906e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.12
Other   |            | 0.005902   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5456 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272184 ave      272184 max      272184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272184
Ave neighs/atom = 136.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.959128760609, Press = -0.743674326262058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -13444.743     -13444.743     -13530.183     -13530.183      330.6595       330.6595       31350.414      31350.414     -1201.0571     -1201.0571    
    112000  -13442.798     -13442.798     -13529.74      -13529.74       336.4749       336.4749       31342.693      31342.693     -265.57704     -265.57704    
Loop time of 51.4032 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.681 ns/day, 14.279 hours/ns, 19.454 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.316     | 51.316     | 51.316     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019113   | 0.019113   | 0.019113   |   0.0 |  0.04
Output  | 3.0457e-05 | 3.0457e-05 | 3.0457e-05 |   0.0 |  0.00
Modify  | 0.061721   | 0.061721   | 0.061721   |   0.0 |  0.12
Other   |            | 0.005919   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5449 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272180 ave      272180 max      272180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272180
Ave neighs/atom = 136.09
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.947422959619, Press = -1.21366222357817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -13442.798     -13442.798     -13529.74      -13529.74       336.4749       336.4749       31342.693      31342.693     -265.57704     -265.57704    
    113000  -13445.814     -13445.814     -13532.495     -13532.495      335.46741      335.46741      31287.547      31287.547      3808.7228      3808.7228    
Loop time of 51.4734 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.679 ns/day, 14.298 hours/ns, 19.428 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.387     | 51.387     | 51.387     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.019165   | 0.019165   | 0.019165   |   0.0 |  0.04
Output  | 2.9676e-05 | 2.9676e-05 | 2.9676e-05 |   0.0 |  0.00
Modify  | 0.061683   | 0.061683   | 0.061683   |   0.0 |  0.12
Other   |            | 0.005917   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5441 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272174 ave      272174 max      272174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272174
Ave neighs/atom = 136.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.947246058095, Press = -0.816822300746756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -13445.814     -13445.814     -13532.495     -13532.495      335.46741      335.46741      31287.547      31287.547      3808.7228      3808.7228    
    114000  -13445.365     -13445.365     -13532.251     -13532.251      336.25752      336.25752      31312.286      31312.286      1854.9078      1854.9078    
Loop time of 51.5164 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.677 ns/day, 14.310 hours/ns, 19.411 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 51.43      | 51.43      | 51.43      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01919    | 0.01919    | 0.01919    |   0.0 |  0.04
Output  | 2.3354e-05 | 2.3354e-05 | 2.3354e-05 |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.12
Other   |            | 0.005913   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5463 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       272218 ave      272218 max      272218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272218
Ave neighs/atom = 136.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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
31335.0133733803

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0