# 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_486450342170_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 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 273.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "273.15 - 0.2"
variable      T_up  equal  "273.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_486450342170_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13549.42      -13549.42      -13620         -13620          273.15         273.15         31153.556      31153.556      2419.8695      2419.8695    
      1000  -13477.19      -13477.19      -13555.159     -13555.159      301.74637      301.74637      31261.825      31261.825      2457.9577      2457.9577    
Loop time of 16.8681 on 1 procs for 1000 steps with 2000 atoms

Performance: 5.122 ns/day, 4.686 hours/ns, 59.284 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 16.787     | 16.787     | 16.787     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015194   | 0.015194   | 0.015194   |   0.0 |  0.09
Output  | 0.00012849 | 0.00012849 | 0.00012849 |   0.0 |  0.00
Modify  | 0.060065   | 0.060065   | 0.060065   |   0.0 |  0.36
Other   |            | 0.005413   |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13477.19      -13477.19      -13555.159     -13555.159      301.74637      301.74637      31261.825      31261.825      2457.9577      2457.9577    
      2000  -13475.798     -13475.798     -13547.037     -13547.037      275.70329      275.70329      31271.943      31271.943      2975.2488      2975.2488    
Loop time of 21.3861 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.040 ns/day, 5.941 hours/ns, 46.759 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.307     | 21.307     | 21.307     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014891   | 0.014891   | 0.014891   |   0.0 |  0.07
Output  | 4.0105e-05 | 4.0105e-05 | 4.0105e-05 |   0.0 |  0.00
Modify  | 0.059388   | 0.059388   | 0.059388   |   0.0 |  0.28
Other   |            | 0.005255   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133752 ave      133752 max      133752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133752
Ave neighs/atom = 66.876
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13475.798     -13475.798     -13547.037     -13547.037      275.70329      275.70329      31271.943      31271.943      2975.2488      2975.2488    
      3000  -13478.957     -13478.957     -13547.341     -13547.341      264.65222      264.65222      31278.949      31278.949      1881.5975      1881.5975    
Loop time of 21.5484 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.010 ns/day, 5.986 hours/ns, 46.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    | 21.469     | 21.469     | 21.469     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.07
Output  | 7.8628e-05 | 7.8628e-05 | 7.8628e-05 |   0.0 |  0.00
Modify  | 0.059333   | 0.059333   | 0.059333   |   0.0 |  0.28
Other   |            | 0.005166   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134246 ave      134246 max      134246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134246
Ave neighs/atom = 67.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13478.957     -13478.957     -13547.341     -13547.341      264.65222      264.65222      31278.949      31278.949      1881.5975      1881.5975    
      4000  -13475.231     -13475.231     -13545.016     -13545.016      270.07625      270.07625      31291.288      31291.288      1163.3165      1163.3165    
Loop time of 21.6331 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.994 ns/day, 6.009 hours/ns, 46.225 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.554     | 21.554     | 21.554     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.07
Output  | 4.0656e-05 | 4.0656e-05 | 4.0656e-05 |   0.0 |  0.00
Modify  | 0.059351   | 0.059351   | 0.059351   |   0.0 |  0.27
Other   |            | 0.005262   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134238 ave      134238 max      134238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134238
Ave neighs/atom = 67.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13475.231     -13475.231     -13545.016     -13545.016      270.07625      270.07625      31291.288      31291.288      1163.3165      1163.3165    
      5000  -13479.371     -13479.371     -13546.566     -13546.566      260.05428      260.05428      31287.275      31287.275      953.39457      953.39457    
Loop time of 21.6078 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.999 ns/day, 6.002 hours/ns, 46.279 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.528     | 21.528     | 21.528     |   0.0 | 99.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015002   | 0.015002   | 0.015002   |   0.0 |  0.07
Output  | 4.243e-05  | 4.243e-05  | 4.243e-05  |   0.0 |  0.00
Modify  | 0.059581   | 0.059581   | 0.059581   |   0.0 |  0.28
Other   |            | 0.005252   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134504 ave      134504 max      134504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134504
Ave neighs/atom = 67.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.445955057633, Press = -18.3820695302933
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13479.371     -13479.371     -13546.566     -13546.566      260.05428      260.05428      31287.275      31287.275      953.39457      953.39457    
      6000  -13475.5       -13475.5       -13549.993     -13549.993      288.29517      288.29517      31283.443      31283.443      1266.9356      1266.9356    
Loop time of 21.7517 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.972 ns/day, 6.042 hours/ns, 45.973 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.67      | 21.67      | 21.67      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014971   | 0.014971   | 0.014971   |   0.0 |  0.07
Output  | 3.1239e-05 | 3.1239e-05 | 3.1239e-05 |   0.0 |  0.00
Modify  | 0.061662   | 0.061662   | 0.061662   |   0.0 |  0.28
Other   |            | 0.005244   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134590 ave      134590 max      134590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134590
Ave neighs/atom = 67.295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.641695700588, Press = 18.4353535458035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13475.5       -13475.5       -13549.993     -13549.993      288.29517      288.29517      31283.443      31283.443      1266.9356      1266.9356    
      7000  -13477.173     -13477.173     -13546.591     -13546.591      268.65234      268.65234      31293.197      31293.197      751.96953      751.96953    
Loop time of 21.674 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.986 ns/day, 6.021 hours/ns, 46.138 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.592     | 21.592     | 21.592     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015022   | 0.015022   | 0.015022   |   0.0 |  0.07
Output  | 4.1408e-05 | 4.1408e-05 | 4.1408e-05 |   0.0 |  0.00
Modify  | 0.061775   | 0.061775   | 0.061775   |   0.0 |  0.29
Other   |            | 0.005348   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134118 ave      134118 max      134118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134118
Ave neighs/atom = 67.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 = 272.731178741083, Press = 13.1485600650077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13477.173     -13477.173     -13546.591     -13546.591      268.65234      268.65234      31293.197      31293.197      751.96953      751.96953    
      8000  -13478.967     -13478.967     -13548.386     -13548.386      268.65923      268.65923      31299.855      31299.855      15.117174      15.117174    
Loop time of 21.7453 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.973 ns/day, 6.040 hours/ns, 45.987 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.663     | 21.663     | 21.663     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.07
Output  | 3.0327e-05 | 3.0327e-05 | 3.0327e-05 |   0.0 |  0.00
Modify  | 0.061665   | 0.061665   | 0.061665   |   0.0 |  0.28
Other   |            | 0.005277   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134358 ave      134358 max      134358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134358
Ave neighs/atom = 67.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.476579523922, Press = -1.37976724468941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13478.967     -13478.967     -13548.386     -13548.386      268.65923      268.65923      31299.855      31299.855      15.117174      15.117174    
      9000  -13476.951     -13476.951     -13547.14      -13547.14       271.63875      271.63875      31308.086      31308.086     -370.17033     -370.17033    
Loop time of 21.7283 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.036 hours/ns, 46.023 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.646     | 21.646     | 21.646     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.07
Output  | 3.4435e-05 | 3.4435e-05 | 3.4435e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.28
Other   |            | 0.005274   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134100 ave      134100 max      134100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134100
Ave neighs/atom = 67.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 = 272.328524224208, Press = -2.69276753672245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13476.951     -13476.951     -13547.14      -13547.14       271.63875      271.63875      31308.086      31308.086     -370.17033     -370.17033    
     10000  -13481.873     -13481.873     -13549.928     -13549.928      263.38231      263.38231      31301.594      31301.594     -275.31084     -275.31084    
Loop time of 21.5658 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.006 ns/day, 5.990 hours/ns, 46.370 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.484     | 21.484     | 21.484     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.07
Output  | 4.2449e-05 | 4.2449e-05 | 4.2449e-05 |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.29
Other   |            | 0.005269   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134114 ave      134114 max      134114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134114
Ave neighs/atom = 67.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 = 272.176629229897, Press = -4.38458188490686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13481.873     -13481.873     -13549.928     -13549.928      263.38231      263.38231      31301.594      31301.594     -275.31084     -275.31084    
     11000  -13477.186     -13477.186     -13548.719     -13548.719      276.84254      276.84254      31307.535      31307.535     -619.41923     -619.41923    
Loop time of 21.7142 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.979 ns/day, 6.032 hours/ns, 46.053 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.632     | 21.632     | 21.632     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014947   | 0.014947   | 0.014947   |   0.0 |  0.07
Output  | 3.1289e-05 | 3.1289e-05 | 3.1289e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.28
Other   |            | 0.005265   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133760 ave      133760 max      133760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133760
Ave neighs/atom = 66.88
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.021356612059, Press = -2.4675322184086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13477.186     -13477.186     -13548.719     -13548.719      276.84254      276.84254      31307.535      31307.535     -619.41923     -619.41923    
     12000  -13477.491     -13477.491     -13547.635     -13547.635      271.46645      271.46645      31317.206      31317.206     -1225.1467     -1225.1467    
Loop time of 21.6186 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.997 ns/day, 6.005 hours/ns, 46.256 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.537     | 21.537     | 21.537     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.07
Output  | 3.3332e-05 | 3.3332e-05 | 3.3332e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.29
Other   |            | 0.005242   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134208 ave      134208 max      134208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134208
Ave neighs/atom = 67.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.294602975306, Press = -1.62498088868088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13477.491     -13477.491     -13547.635     -13547.635      271.46645      271.46645      31317.206      31317.206     -1225.1467     -1225.1467    
     13000  -13476.84      -13476.84      -13547.916     -13547.916      275.07353      275.07353      31340.576      31340.576     -3346.0319     -3346.0319    
Loop time of 21.6669 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.988 ns/day, 6.019 hours/ns, 46.153 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.585     | 21.585     | 21.585     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.07
Output  | 4.2219e-05 | 4.2219e-05 | 4.2219e-05 |   0.0 |  0.00
Modify  | 0.061621   | 0.061621   | 0.061621   |   0.0 |  0.28
Other   |            | 0.005251   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134146 ave      134146 max      134146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134146
Ave neighs/atom = 67.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 = 272.297066224546, Press = -2.45756521143715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13476.84      -13476.84      -13547.916     -13547.916      275.07353      275.07353      31340.576      31340.576     -3346.0319     -3346.0319    
     14000  -13475.919     -13475.919     -13546.488     -13546.488      273.11058      273.11058      31346.499      31346.499     -3691.3827     -3691.3827    
Loop time of 21.6536 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.015 hours/ns, 46.182 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.572     | 21.572     | 21.572     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015004   | 0.015004   | 0.015004   |   0.0 |  0.07
Output  | 3.1188e-05 | 3.1188e-05 | 3.1188e-05 |   0.0 |  0.00
Modify  | 0.061666   | 0.061666   | 0.061666   |   0.0 |  0.28
Other   |            | 0.005258   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133618 ave      133618 max      133618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133618
Ave neighs/atom = 66.809
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.446342353247, Press = -4.45066214503696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13475.919     -13475.919     -13546.488     -13546.488      273.11058      273.11058      31346.499      31346.499     -3691.3827     -3691.3827    
     15000  -13476.639     -13476.639     -13548.09      -13548.09       276.5229       276.5229       31318.633      31318.633     -1442.9446     -1442.9446    
Loop time of 21.6601 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.989 ns/day, 6.017 hours/ns, 46.168 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.578     | 21.578     | 21.578     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014888   | 0.014888   | 0.014888   |   0.0 |  0.07
Output  | 2.9225e-05 | 2.9225e-05 | 2.9225e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.28
Other   |            | 0.005259   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133682 ave      133682 max      133682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133682
Ave neighs/atom = 66.841
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.397454972835, Press = -5.25664270850556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13476.639     -13476.639     -13548.09      -13548.09       276.5229       276.5229       31318.633      31318.633     -1442.9446     -1442.9446    
     16000  -13478.727     -13478.727     -13547.636     -13547.636      266.68333      266.68333      31312.606      31312.606     -1088.1828     -1088.1828    
Loop time of 21.6781 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.986 ns/day, 6.022 hours/ns, 46.129 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.596     | 21.596     | 21.596     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015014   | 0.015014   | 0.015014   |   0.0 |  0.07
Output  | 4.0676e-05 | 4.0676e-05 | 4.0676e-05 |   0.0 |  0.00
Modify  | 0.061689   | 0.061689   | 0.061689   |   0.0 |  0.28
Other   |            | 0.00529    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133988 ave      133988 max      133988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133988
Ave neighs/atom = 66.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.512745233471, Press = -5.39009032634552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13478.727     -13478.727     -13547.636     -13547.636      266.68333      266.68333      31312.606      31312.606     -1088.1828     -1088.1828    
     17000  -13475.584     -13475.584     -13546.476     -13546.476      274.35758      274.35758      31321.633      31321.633     -1533.155      -1533.155     
Loop time of 21.7089 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.030 hours/ns, 46.064 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.627     | 21.627     | 21.627     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.07
Output  | 2.9936e-05 | 2.9936e-05 | 2.9936e-05 |   0.0 |  0.00
Modify  | 0.061734   | 0.061734   | 0.061734   |   0.0 |  0.28
Other   |            | 0.005264   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134132 ave      134132 max      134132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134132
Ave neighs/atom = 67.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 = 272.5030537443, Press = -5.83952587075773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13475.584     -13475.584     -13546.476     -13546.476      274.35758      274.35758      31321.633      31321.633     -1533.155      -1533.155     
     18000  -13480.436     -13480.436     -13548.67      -13548.67       264.07018      264.07018      31319.603      31319.603     -1598.5376     -1598.5376    
Loop time of 21.7021 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.981 ns/day, 6.028 hours/ns, 46.079 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.62      | 21.62      | 21.62      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.07
Output  | 3.3403e-05 | 3.3403e-05 | 3.3403e-05 |   0.0 |  0.00
Modify  | 0.061756   | 0.061756   | 0.061756   |   0.0 |  0.28
Other   |            | 0.005262   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133990 ave      133990 max      133990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133990
Ave neighs/atom = 66.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.371445260445, Press = -7.609932432105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13480.436     -13480.436     -13548.67      -13548.67       264.07018      264.07018      31319.603      31319.603     -1598.5376     -1598.5376    
     19000  -13476.285     -13476.285     -13546.951     -13546.951      273.48718      273.48718      31309.374      31309.374     -590.19852     -590.19852    
Loop time of 21.5615 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.007 ns/day, 5.989 hours/ns, 46.379 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.479     | 21.479     | 21.479     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01506    | 0.01506    | 0.01506    |   0.0 |  0.07
Output  | 4.3392e-05 | 4.3392e-05 | 4.3392e-05 |   0.0 |  0.00
Modify  | 0.061758   | 0.061758   | 0.061758   |   0.0 |  0.29
Other   |            | 0.005288   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133802 ave      133802 max      133802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133802
Ave neighs/atom = 66.901
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.284382743324, Press = -8.04320398357891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13476.285     -13476.285     -13546.951     -13546.951      273.48718      273.48718      31309.374      31309.374     -590.19852     -590.19852    
     20000  -13479.46      -13479.46      -13549.897     -13549.897      272.59552      272.59552      31295.119      31295.119      171.1222       171.1222     
Loop time of 21.7295 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.976 ns/day, 6.036 hours/ns, 46.020 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.648     | 21.648     | 21.648     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014892   | 0.014892   | 0.014892   |   0.0 |  0.07
Output  | 3.0908e-05 | 3.0908e-05 | 3.0908e-05 |   0.0 |  0.00
Modify  | 0.061703   | 0.061703   | 0.061703   |   0.0 |  0.28
Other   |            | 0.005271   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134172 ave      134172 max      134172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134172
Ave neighs/atom = 67.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 = 272.222831467206, Press = -4.22444530858233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13479.46      -13479.46      -13549.897     -13549.897      272.59552      272.59552      31295.119      31295.119      171.1222       171.1222     
     21000  -13475.522     -13475.522     -13547.203     -13547.203      277.41254      277.41254      31291.479      31291.479      1122.9094      1122.9094    
Loop time of 21.6766 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.986 ns/day, 6.021 hours/ns, 46.133 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.595     | 21.595     | 21.595     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.07
Output  | 3.748e-05  | 3.748e-05  | 3.748e-05  |   0.0 |  0.00
Modify  | 0.061727   | 0.061727   | 0.061727   |   0.0 |  0.28
Other   |            | 0.005287   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133998 ave      133998 max      133998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133998
Ave neighs/atom = 66.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.1827786476, Press = -2.23658590756047
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13475.522     -13475.522     -13547.203     -13547.203      277.41254      277.41254      31291.479      31291.479      1122.9094      1122.9094    
     22000  -13481.484     -13481.484     -13549.33      -13549.33       262.57254      262.57254      31271.512      31271.512      2255.5219      2255.5219    
Loop time of 21.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.989 ns/day, 6.016 hours/ns, 46.172 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.576     | 21.576     | 21.576     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.07
Output  | 2.9535e-05 | 2.9535e-05 | 2.9535e-05 |   0.0 |  0.00
Modify  | 0.061772   | 0.061772   | 0.061772   |   0.0 |  0.29
Other   |            | 0.00527    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134216 ave      134216 max      134216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134216
Ave neighs/atom = 67.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 = 272.176828233833, Press = -1.657810870612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13481.484     -13481.484     -13549.33      -13549.33       262.57254      262.57254      31271.512      31271.512      2255.5219      2255.5219    
     23000  -13476.491     -13476.491     -13548.817     -13548.817      279.90957      279.90957      31267.582      31267.582      2732.2987      2732.2987    
Loop time of 21.9791 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.931 ns/day, 6.105 hours/ns, 45.498 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.896     | 21.896     | 21.896     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015261   | 0.015261   | 0.015261   |   0.0 |  0.07
Output  | 2.8383e-05 | 2.8383e-05 | 2.8383e-05 |   0.0 |  0.00
Modify  | 0.062499   | 0.062499   | 0.062499   |   0.0 |  0.28
Other   |            | 0.00534    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134344 ave      134344 max      134344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134344
Ave neighs/atom = 67.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.145843137661, Press = -0.0209940697469021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13476.491     -13476.491     -13548.817     -13548.817      279.90957      279.90957      31267.582      31267.582      2732.2987      2732.2987    
     24000  -13479.784     -13479.784     -13549.43      -13549.43       269.5375       269.5375       31270.673      31270.673      2367.385       2367.385     
Loop time of 22.0426 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.920 ns/day, 6.123 hours/ns, 45.367 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.96      | 21.96      | 21.96      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015087   | 0.015087   | 0.015087   |   0.0 |  0.07
Output  | 3.9164e-05 | 3.9164e-05 | 3.9164e-05 |   0.0 |  0.00
Modify  | 0.062417   | 0.062417   | 0.062417   |   0.0 |  0.28
Other   |            | 0.005332   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134482 ave      134482 max      134482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134482
Ave neighs/atom = 67.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.111992893344, Press = 1.48749044009469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13479.784     -13479.784     -13549.43      -13549.43       269.5375       269.5375       31270.673      31270.673      2367.385       2367.385     
     25000  -13475.601     -13475.601     -13547.946     -13547.946      279.98035      279.98035      31302.823      31302.823     -35.16824      -35.16824     
Loop time of 21.9859 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.930 ns/day, 6.107 hours/ns, 45.484 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.903     | 21.903     | 21.903     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015187   | 0.015187   | 0.015187   |   0.0 |  0.07
Output  | 3.0236e-05 | 3.0236e-05 | 3.0236e-05 |   0.0 |  0.00
Modify  | 0.062332   | 0.062332   | 0.062332   |   0.0 |  0.28
Other   |            | 0.005314   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134298 ave      134298 max      134298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134298
Ave neighs/atom = 67.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.079450387768, Press = -0.0430438580043484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13475.601     -13475.601     -13547.946     -13547.946      279.98035      279.98035      31302.823      31302.823     -35.16824      -35.16824     
     26000  -13478.725     -13478.725     -13547.998     -13547.998      268.09201      268.09201      31305.464      31305.464     -520.84904     -520.84904    
Loop time of 21.9111 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.943 ns/day, 6.086 hours/ns, 45.639 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.828     | 21.828     | 21.828     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015149   | 0.015149   | 0.015149   |   0.0 |  0.07
Output  | 2.9966e-05 | 2.9966e-05 | 2.9966e-05 |   0.0 |  0.00
Modify  | 0.062319   | 0.062319   | 0.062319   |   0.0 |  0.28
Other   |            | 0.005301   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134162 ave      134162 max      134162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134162
Ave neighs/atom = 67.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 = 272.066892690082, Press = -1.10754583884602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13478.725     -13478.725     -13547.998     -13547.998      268.09201      268.09201      31305.464      31305.464     -520.84904     -520.84904    
     27000  -13476.971     -13476.971     -13548.083     -13548.083      275.21114      275.21114      31305.094      31305.094     -396.51588     -396.51588    
Loop time of 21.8813 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.949 ns/day, 6.078 hours/ns, 45.701 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.799     | 21.799     | 21.799     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015039   | 0.015039   | 0.015039   |   0.0 |  0.07
Output  | 4.2029e-05 | 4.2029e-05 | 4.2029e-05 |   0.0 |  0.00
Modify  | 0.062153   | 0.062153   | 0.062153   |   0.0 |  0.28
Other   |            | 0.005304   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134094 ave      134094 max      134094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134094
Ave neighs/atom = 67.047
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.119590933927, Press = -1.72433361265343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13476.971     -13476.971     -13548.083     -13548.083      275.21114      275.21114      31305.094      31305.094     -396.51588     -396.51588    
     28000  -13477.365     -13477.365     -13547.925     -13547.925      273.07498      273.07498      31300.971      31300.971      2.3197064      2.3197064    
Loop time of 21.8327 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.957 ns/day, 6.065 hours/ns, 45.803 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.75      | 21.75      | 21.75      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015098   | 0.015098   | 0.015098   |   0.0 |  0.07
Output  | 2.9495e-05 | 2.9495e-05 | 2.9495e-05 |   0.0 |  0.00
Modify  | 0.062188   | 0.062188   | 0.062188   |   0.0 |  0.28
Other   |            | 0.005305   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134020 ave      134020 max      134020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134020
Ave neighs/atom = 67.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.129877598004, Press = -1.55961536826475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13477.365     -13477.365     -13547.925     -13547.925      273.07498      273.07498      31300.971      31300.971      2.3197064      2.3197064    
     29000  -13476.94      -13476.94      -13547.695     -13547.695      273.82775      273.82775      31296.684      31296.684      332.00118      332.00118    
Loop time of 21.8789 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.949 ns/day, 6.077 hours/ns, 45.706 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.796     | 21.796     | 21.796     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015146   | 0.015146   | 0.015146   |   0.0 |  0.07
Output  | 2.9475e-05 | 2.9475e-05 | 2.9475e-05 |   0.0 |  0.00
Modify  | 0.062403   | 0.062403   | 0.062403   |   0.0 |  0.29
Other   |            | 0.005327   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133966 ave      133966 max      133966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133966
Ave neighs/atom = 66.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.217189950482, Press = -1.2607290465817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13476.94      -13476.94      -13547.695     -13547.695      273.82775      273.82775      31296.684      31296.684      332.00118      332.00118    
     30000  -13478.659     -13478.659     -13547.149     -13547.149      265.06301      265.06301      31298.069      31298.069      311.3806       311.3806     
Loop time of 21.9061 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.944 ns/day, 6.085 hours/ns, 45.649 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.823     | 21.823     | 21.823     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015119   | 0.015119   | 0.015119   |   0.0 |  0.07
Output  | 4.0656e-05 | 4.0656e-05 | 4.0656e-05 |   0.0 |  0.00
Modify  | 0.062434   | 0.062434   | 0.062434   |   0.0 |  0.29
Other   |            | 0.005315   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134116 ave      134116 max      134116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134116
Ave neighs/atom = 67.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 = 272.173173961816, Press = -0.78059668520574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13478.659     -13478.659     -13547.149     -13547.149      265.06301      265.06301      31298.069      31298.069      311.3806       311.3806     
     31000  -13477.029     -13477.029     -13546.997     -13546.997      270.7808       270.7808       31313.442      31313.442     -973.81913     -973.81913    
Loop time of 21.9307 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.940 ns/day, 6.092 hours/ns, 45.598 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.848     | 21.848     | 21.848     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015181   | 0.015181   | 0.015181   |   0.0 |  0.07
Output  | 3.0537e-05 | 3.0537e-05 | 3.0537e-05 |   0.0 |  0.00
Modify  | 0.062325   | 0.062325   | 0.062325   |   0.0 |  0.28
Other   |            | 0.00533    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134124 ave      134124 max      134124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134124
Ave neighs/atom = 67.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 = 272.181019979866, Press = -0.371783335764496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13477.029     -13477.029     -13546.997     -13546.997      270.7808       270.7808       31313.442      31313.442     -973.81913     -973.81913    
     32000  -13478.297     -13478.297     -13547.576     -13547.576      268.11566      268.11566      31333.304      31333.304     -2740.7639     -2740.7639    
Loop time of 21.8636 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.073 hours/ns, 45.738 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.781     | 21.781     | 21.781     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015087   | 0.015087   | 0.015087   |   0.0 |  0.07
Output  | 3.8993e-05 | 3.8993e-05 | 3.8993e-05 |   0.0 |  0.00
Modify  | 0.06237    | 0.06237    | 0.06237    |   0.0 |  0.29
Other   |            | 0.005299   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133934 ave      133934 max      133934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133934
Ave neighs/atom = 66.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.131712848107, Press = -0.429692565786472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13478.297     -13478.297     -13547.576     -13547.576      268.11566      268.11566      31333.304      31333.304     -2740.7639     -2740.7639    
     33000  -13478.311     -13478.311     -13546.335     -13546.335      263.25649      263.25649      31333.749      31333.749     -2738.613      -2738.613     
Loop time of 21.8632 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.952 ns/day, 6.073 hours/ns, 45.739 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.781     | 21.781     | 21.781     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015132   | 0.015132   | 0.015132   |   0.0 |  0.07
Output  | 3.0607e-05 | 3.0607e-05 | 3.0607e-05 |   0.0 |  0.00
Modify  | 0.062204   | 0.062204   | 0.062204   |   0.0 |  0.28
Other   |            | 0.005292   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133638 ave      133638 max      133638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133638
Ave neighs/atom = 66.819
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.229875882157, Press = -0.981995124415191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13478.311     -13478.311     -13546.335     -13546.335      263.25649      263.25649      31333.749      31333.749     -2738.613      -2738.613     
     34000  -13475.605     -13475.605     -13545.31      -13545.31       269.76513      269.76513      31320.503      31320.503     -1448.2628     -1448.2628    
Loop time of 21.7926 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.054 hours/ns, 45.887 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.71      | 21.71      | 21.71      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015151   | 0.015151   | 0.015151   |   0.0 |  0.07
Output  | 2.9405e-05 | 2.9405e-05 | 2.9405e-05 |   0.0 |  0.00
Modify  | 0.062187   | 0.062187   | 0.062187   |   0.0 |  0.29
Other   |            | 0.005289   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133964 ave      133964 max      133964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133964
Ave neighs/atom = 66.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.305742998602, Press = -1.47358715264434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13475.605     -13475.605     -13545.31      -13545.31       269.76513      269.76513      31320.503      31320.503     -1448.2628     -1448.2628    
     35000  -13478.797     -13478.797     -13546.81      -13546.81       263.21862      263.21862      31301.095      31301.095      67.142789      67.142789    
Loop time of 21.8909 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.947 ns/day, 6.081 hours/ns, 45.681 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.808     | 21.808     | 21.808     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015179   | 0.015179   | 0.015179   |   0.0 |  0.07
Output  | 4.1077e-05 | 4.1077e-05 | 4.1077e-05 |   0.0 |  0.00
Modify  | 0.06221    | 0.06221    | 0.06221    |   0.0 |  0.28
Other   |            | 0.005338   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134206 ave      134206 max      134206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134206
Ave neighs/atom = 67.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.379168278099, Press = -1.55478527467352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13478.797     -13478.797     -13546.81      -13546.81       263.21862      263.21862      31301.095      31301.095      67.142789      67.142789    
     36000  -13472.76      -13472.76      -13547.119     -13547.119      287.77653      287.77653      31298.343      31298.343      515.30349      515.30349    
Loop time of 21.9052 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.944 ns/day, 6.085 hours/ns, 45.651 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.823     | 21.823     | 21.823     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.07
Output  | 3.4044e-05 | 3.4044e-05 | 3.4044e-05 |   0.0 |  0.00
Modify  | 0.062084   | 0.062084   | 0.062084   |   0.0 |  0.28
Other   |            | 0.005275   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134366 ave      134366 max      134366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134366
Ave neighs/atom = 67.183
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.468418328912, Press = -1.63296831456958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13472.76      -13472.76      -13547.119     -13547.119      287.77653      287.77653      31298.343      31298.343      515.30349      515.30349    
     37000  -13478.761     -13478.761     -13549.698     -13549.698      274.5353       274.5353       31277.842      31277.842      1808.2842      1808.2842    
Loop time of 21.9279 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.940 ns/day, 6.091 hours/ns, 45.604 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.845     | 21.845     | 21.845     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015107   | 0.015107   | 0.015107   |   0.0 |  0.07
Output  | 2.9936e-05 | 2.9936e-05 | 2.9936e-05 |   0.0 |  0.00
Modify  | 0.062266   | 0.062266   | 0.062266   |   0.0 |  0.28
Other   |            | 0.005289   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134148 ave      134148 max      134148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134148
Ave neighs/atom = 67.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 = 272.504325660543, Press = -1.6910207659408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13478.761     -13478.761     -13549.698     -13549.698      274.5353       274.5353       31277.842      31277.842      1808.2842      1808.2842    
     38000  -13477.322     -13477.322     -13547.108     -13547.108      270.07936      270.07936      31253.561      31253.561      4220.9449      4220.9449    
Loop time of 21.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.939 ns/day, 6.093 hours/ns, 45.593 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.85      | 21.85      | 21.85      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015069   | 0.015069   | 0.015069   |   0.0 |  0.07
Output  | 4.2209e-05 | 4.2209e-05 | 4.2209e-05 |   0.0 |  0.00
Modify  | 0.062316   | 0.062316   | 0.062316   |   0.0 |  0.28
Other   |            | 0.005298   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134100 ave      134100 max      134100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134100
Ave neighs/atom = 67.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 = 272.521955979117, Press = -0.840406864574063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13477.322     -13477.322     -13547.108     -13547.108      270.07936      270.07936      31253.561      31253.561      4220.9449      4220.9449    
     39000  -13479.057     -13479.057     -13549.112     -13549.112      271.12198      271.12198      31264.59       31264.59       2897.0358      2897.0358    
Loop time of 21.9095 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.943 ns/day, 6.086 hours/ns, 45.642 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.827     | 21.827     | 21.827     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015113   | 0.015113   | 0.015113   |   0.0 |  0.07
Output  | 3.1279e-05 | 3.1279e-05 | 3.1279e-05 |   0.0 |  0.00
Modify  | 0.062166   | 0.062166   | 0.062166   |   0.0 |  0.28
Other   |            | 0.005304   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134762 ave      134762 max      134762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134762
Ave neighs/atom = 67.381
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.460962403444, Press = -0.209902659553451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13479.057     -13479.057     -13549.112     -13549.112      271.12198      271.12198      31264.59       31264.59       2897.0358      2897.0358    
     40000  -13477.506     -13477.506     -13548.653     -13548.653      275.34613      275.34613      31278.248      31278.248      1744.9041      1744.9041    
Loop time of 21.9274 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.940 ns/day, 6.091 hours/ns, 45.605 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.845     | 21.845     | 21.845     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015135   | 0.015135   | 0.015135   |   0.0 |  0.07
Output  | 4.3421e-05 | 4.3421e-05 | 4.3421e-05 |   0.0 |  0.00
Modify  | 0.062344   | 0.062344   | 0.062344   |   0.0 |  0.28
Other   |            | 0.005313   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134678 ave      134678 max      134678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134678
Ave neighs/atom = 67.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.456677121865, Press = 0.170980743835279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13477.506     -13477.506     -13548.653     -13548.653      275.34613      275.34613      31278.248      31278.248      1744.9041      1744.9041    
     41000  -13474.299     -13474.299     -13544.584     -13544.584      272.01251      272.01251      31297.332      31297.332      703.28532      703.28532    
Loop time of 21.8391 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.956 ns/day, 6.066 hours/ns, 45.789 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.755     | 21.755     | 21.755     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015663   | 0.015663   | 0.015663   |   0.0 |  0.07
Output  | 4.1828e-05 | 4.1828e-05 | 4.1828e-05 |   0.0 |  0.00
Modify  | 0.062806   | 0.062806   | 0.062806   |   0.0 |  0.29
Other   |            | 0.005444   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134294 ave      134294 max      134294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134294
Ave neighs/atom = 67.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.466199464898, Press = 0.243278145057733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13474.299     -13474.299     -13544.584     -13544.584      272.01251      272.01251      31297.332      31297.332      703.28532      703.28532    
     42000  -13477.993     -13477.993     -13548.067     -13548.067      271.19307      271.19307      31307.032      31307.032     -692.75113     -692.75113    
Loop time of 21.8316 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.958 ns/day, 6.064 hours/ns, 45.805 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.748     | 21.748     | 21.748     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015368   | 0.015368   | 0.015368   |   0.0 |  0.07
Output  | 4.1177e-05 | 4.1177e-05 | 4.1177e-05 |   0.0 |  0.00
Modify  | 0.062435   | 0.062435   | 0.062435   |   0.0 |  0.29
Other   |            | 0.005328   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134508 ave      134508 max      134508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134508
Ave neighs/atom = 67.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.507715037923, Press = -0.114530594096768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13477.993     -13477.993     -13548.067     -13548.067      271.19307      271.19307      31307.032      31307.032     -692.75113     -692.75113    
     43000  -13473.818     -13473.818     -13546.724     -13546.724      282.15353      282.15353      31313.766      31313.766     -862.91652     -862.91652    
Loop time of 21.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.975 ns/day, 6.038 hours/ns, 46.007 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.653     | 21.653     | 21.653     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015094   | 0.015094   | 0.015094   |   0.0 |  0.07
Output  | 4.3051e-05 | 4.3051e-05 | 4.3051e-05 |   0.0 |  0.00
Modify  | 0.06218    | 0.06218    | 0.06218    |   0.0 |  0.29
Other   |            | 0.005244   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134208 ave      134208 max      134208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134208
Ave neighs/atom = 67.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.588551716668, Press = -0.523624603293642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13473.818     -13473.818     -13546.724     -13546.724      282.15353      282.15353      31313.766      31313.766     -862.91652     -862.91652    
     44000  -13475.873     -13475.873     -13546.775     -13546.775      274.40034      274.40034      31315.52       31315.52      -909.60959     -909.60959    
Loop time of 21.7692 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.969 ns/day, 6.047 hours/ns, 45.937 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.686     | 21.686     | 21.686     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015181   | 0.015181   | 0.015181   |   0.0 |  0.07
Output  | 3.8292e-05 | 3.8292e-05 | 3.8292e-05 |   0.0 |  0.00
Modify  | 0.062244   | 0.062244   | 0.062244   |   0.0 |  0.29
Other   |            | 0.005308   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134212 ave      134212 max      134212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134212
Ave neighs/atom = 67.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.628267169564, Press = -0.928624742862438
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13475.873     -13475.873     -13546.775     -13546.775      274.40034      274.40034      31315.52       31315.52      -909.60959     -909.60959    
     45000  -13479.072     -13479.072     -13548.05      -13548.05       266.95071      266.95071      31304.967      31304.967     -466.32747     -466.32747    
Loop time of 21.8274 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.958 ns/day, 6.063 hours/ns, 45.814 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.745     | 21.745     | 21.745     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.07
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.062072   | 0.062072   | 0.062072   |   0.0 |  0.28
Other   |            | 0.005296   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133994 ave      133994 max      133994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133994
Ave neighs/atom = 66.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633737586578, Press = -1.23149876530961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13479.072     -13479.072     -13548.05      -13548.05       266.95071      266.95071      31304.967      31304.967     -466.32747     -466.32747    
     46000  -13476.192     -13476.192     -13548.091     -13548.091      278.25596      278.25596      31300.278      31300.278     -30.598345     -30.598345    
Loop time of 21.7844 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.966 ns/day, 6.051 hours/ns, 45.904 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.701     | 21.701     | 21.701     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015238   | 0.015238   | 0.015238   |   0.0 |  0.07
Output  | 4.0055e-05 | 4.0055e-05 | 4.0055e-05 |   0.0 |  0.00
Modify  | 0.062394   | 0.062394   | 0.062394   |   0.0 |  0.29
Other   |            | 0.005287   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134132 ave      134132 max      134132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134132
Ave neighs/atom = 67.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 = 272.573541340907, Press = -1.18441252166271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13476.192     -13476.192     -13548.091     -13548.091      278.25596      278.25596      31300.278      31300.278     -30.598345     -30.598345    
     47000  -13477.847     -13477.847     -13548.056     -13548.056      271.71635      271.71635      31299.867      31299.867      32.41308       32.41308     
Loop time of 21.8335 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.957 ns/day, 6.065 hours/ns, 45.801 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.751     | 21.751     | 21.751     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.07
Output  | 4.1819e-05 | 4.1819e-05 | 4.1819e-05 |   0.0 |  0.00
Modify  | 0.062086   | 0.062086   | 0.062086   |   0.0 |  0.28
Other   |            | 0.005246   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134088 ave      134088 max      134088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134088
Ave neighs/atom = 67.044
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.586405896983, Press = -0.879979988614768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13477.847     -13477.847     -13548.056     -13548.056      271.71635      271.71635      31299.867      31299.867      32.41308       32.41308     
     48000  -13475.843     -13475.843     -13547.215     -13547.215      276.21869      276.21869      31303.596      31303.596     -131.73593     -131.73593    
Loop time of 21.8056 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.723     | 21.723     | 21.723     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.07
Output  | 4.1819e-05 | 4.1819e-05 | 4.1819e-05 |   0.0 |  0.00
Modify  | 0.062156   | 0.062156   | 0.062156   |   0.0 |  0.29
Other   |            | 0.005326   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134422 ave      134422 max      134422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134422
Ave neighs/atom = 67.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.638191018968, Press = -0.796877962947943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13475.843     -13475.843     -13547.215     -13547.215      276.21869      276.21869      31303.596      31303.596     -131.73593     -131.73593    
     49000  -13477.076     -13477.076     -13546.094     -13546.094      267.10765      267.10765      31302.213      31302.213      170.69725      170.69725    
Loop time of 21.9183 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.942 ns/day, 6.088 hours/ns, 45.624 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.836     | 21.836     | 21.836     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014988   | 0.014988   | 0.014988   |   0.0 |  0.07
Output  | 4.2329e-05 | 4.2329e-05 | 4.2329e-05 |   0.0 |  0.00
Modify  | 0.062089   | 0.062089   | 0.062089   |   0.0 |  0.28
Other   |            | 0.005286   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134166 ave      134166 max      134166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134166
Ave neighs/atom = 67.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 = 272.662805687891, Press = -0.616100746814388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13477.076     -13477.076     -13546.094     -13546.094      267.10765      267.10765      31302.213      31302.213      170.69725      170.69725    
     50000  -13474.529     -13474.529     -13545.371     -13545.371      274.16642      274.16642      31310.367      31310.367     -278.40231     -278.40231    
Loop time of 22.0083 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.926 ns/day, 6.113 hours/ns, 45.437 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.925     | 21.925     | 21.925     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015107   | 0.015107   | 0.015107   |   0.0 |  0.07
Output  | 3.9805e-05 | 3.9805e-05 | 3.9805e-05 |   0.0 |  0.00
Modify  | 0.062681   | 0.062681   | 0.062681   |   0.0 |  0.28
Other   |            | 0.005331   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134142 ave      134142 max      134142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134142
Ave neighs/atom = 67.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 = 272.747546037536, Press = -0.774716400292522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13474.529     -13474.529     -13545.371     -13545.371      274.16642      274.16642      31310.367      31310.367     -278.40231     -278.40231    
     51000  -13477.021     -13477.021     -13546.263     -13546.263      267.97257      267.97257      31319.498      31319.498     -1204.2995     -1204.2995    
Loop time of 22.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.919 ns/day, 6.124 hours/ns, 45.362 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.962     | 21.962     | 21.962     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015079   | 0.015079   | 0.015079   |   0.0 |  0.07
Output  | 3.4334e-05 | 3.4334e-05 | 3.4334e-05 |   0.0 |  0.00
Modify  | 0.062599   | 0.062599   | 0.062599   |   0.0 |  0.28
Other   |            | 0.005305   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134070 ave      134070 max      134070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134070
Ave neighs/atom = 67.035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.766704786574, Press = -0.652070621939601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13477.021     -13477.021     -13546.263     -13546.263      267.97257      267.97257      31319.498      31319.498     -1204.2995     -1204.2995    
     52000  -13476.011     -13476.011     -13548.006     -13548.006      278.62785      278.62785      31329.931      31329.931     -2390.1639     -2390.1639    
Loop time of 21.79 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.965 ns/day, 6.053 hours/ns, 45.893 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.708     | 21.708     | 21.708     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.07
Output  | 3.0036e-05 | 3.0036e-05 | 3.0036e-05 |   0.0 |  0.00
Modify  | 0.062091   | 0.062091   | 0.062091   |   0.0 |  0.28
Other   |            | 0.005282   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134042 ave      134042 max      134042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134042
Ave neighs/atom = 67.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772533296532, Press = -0.732402872430455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13476.011     -13476.011     -13548.006     -13548.006      278.62785      278.62785      31329.931      31329.931     -2390.1639     -2390.1639    
     53000  -13477.552     -13477.552     -13549.116     -13549.116      276.95887      276.95887      31343.223      31343.223     -3673.1452     -3673.1452    
Loop time of 21.6584 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.989 ns/day, 6.016 hours/ns, 46.171 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.576     | 21.576     | 21.576     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015033   | 0.015033   | 0.015033   |   0.0 |  0.07
Output  | 4.1728e-05 | 4.1728e-05 | 4.1728e-05 |   0.0 |  0.00
Modify  | 0.061883   | 0.061883   | 0.061883   |   0.0 |  0.29
Other   |            | 0.005267   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133786 ave      133786 max      133786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133786
Ave neighs/atom = 66.893
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.773298568719, Press = -0.883095306245768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13477.552     -13477.552     -13549.116     -13549.116      276.95887      276.95887      31343.223      31343.223     -3673.1452     -3673.1452    
     54000  -13473.901     -13473.901     -13546.428     -13546.428      280.68908      280.68908      31344.263      31344.263     -3328.8591     -3328.8591    
Loop time of 21.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.007 hours/ns, 46.239 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.545     | 21.545     | 21.545     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015015   | 0.015015   | 0.015015   |   0.0 |  0.07
Output  | 4.3883e-05 | 4.3883e-05 | 4.3883e-05 |   0.0 |  0.00
Modify  | 0.062007   | 0.062007   | 0.062007   |   0.0 |  0.29
Other   |            | 0.005276   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133556 ave      133556 max      133556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133556
Ave neighs/atom = 66.778
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.783590198414, Press = -1.49382575055253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13473.901     -13473.901     -13546.428     -13546.428      280.68908      280.68908      31344.263      31344.263     -3328.8591     -3328.8591    
     55000  -13478.077     -13478.077     -13549.535     -13549.535      276.55096      276.55096      31313.513      31313.513     -1056.2849     -1056.2849    
Loop time of 21.6448 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.992 ns/day, 6.012 hours/ns, 46.200 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.563     | 21.563     | 21.563     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.07
Output  | 3.0748e-05 | 3.0748e-05 | 3.0748e-05 |   0.0 |  0.00
Modify  | 0.061611   | 0.061611   | 0.061611   |   0.0 |  0.28
Other   |            | 0.005246   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133640 ave      133640 max      133640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133640
Ave neighs/atom = 66.82
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824522158664, Press = -1.51021396413688
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13478.077     -13478.077     -13549.535     -13549.535      276.55096      276.55096      31313.513      31313.513     -1056.2849     -1056.2849    
     56000  -13476.178     -13476.178     -13546.058     -13546.058      270.44475      270.44475      31303.163      31303.163      156.50441      156.50441    
Loop time of 21.5627 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.007 ns/day, 5.990 hours/ns, 46.376 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.481     | 21.481     | 21.481     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.07
Output  | 3.7631e-05 | 3.7631e-05 | 3.7631e-05 |   0.0 |  0.00
Modify  | 0.061723   | 0.061723   | 0.061723   |   0.0 |  0.29
Other   |            | 0.005288   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133664 ave      133664 max      133664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133664
Ave neighs/atom = 66.832
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.87153203896, Press = -1.46406556380726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13476.178     -13476.178     -13546.058     -13546.058      270.44475      270.44475      31303.163      31303.163      156.50441      156.50441    
     57000  -13475.713     -13475.713     -13546.375     -13546.375      273.46735      273.46735      31298.651      31298.651      467.75638      467.75638    
Loop time of 21.7125 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.979 ns/day, 6.031 hours/ns, 46.056 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.631     | 21.631     | 21.631     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014857   | 0.014857   | 0.014857   |   0.0 |  0.07
Output  | 4.0626e-05 | 4.0626e-05 | 4.0626e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.28
Other   |            | 0.00527    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134212 ave      134212 max      134212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134212
Ave neighs/atom = 67.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.882900388129, Press = -1.37571672267238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13475.713     -13475.713     -13546.375     -13546.375      273.46735      273.46735      31298.651      31298.651      467.75638      467.75638    
     58000  -13477.476     -13477.476     -13546.399     -13546.399      266.74019      266.74019      31282.261      31282.261      1691.546       1691.546     
Loop time of 21.7064 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.030 hours/ns, 46.069 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.624     | 21.624     | 21.624     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01512    | 0.01512    | 0.01512    |   0.0 |  0.07
Output  | 4.2981e-05 | 4.2981e-05 | 4.2981e-05 |   0.0 |  0.00
Modify  | 0.062048   | 0.062048   | 0.062048   |   0.0 |  0.29
Other   |            | 0.005217   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134180 ave      134180 max      134180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134180
Ave neighs/atom = 67.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 = 272.93717922568, Press = -1.19979847022567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13477.476     -13477.476     -13546.399     -13546.399      266.74019      266.74019      31282.261      31282.261      1691.546       1691.546     
     59000  -13476.362     -13476.362     -13547.883     -13547.883      276.79291      276.79291      31265.126      31265.126      3073.0679      3073.0679    
Loop time of 21.6716 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.987 ns/day, 6.020 hours/ns, 46.143 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.59      | 21.59      | 21.59      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.07
Output  | 3.9704e-05 | 3.9704e-05 | 3.9704e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.28
Other   |            | 0.005283   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134464 ave      134464 max      134464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134464
Ave neighs/atom = 67.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.937532171839, Press = -0.95044920422975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13476.362     -13476.362     -13547.883     -13547.883      276.79291      276.79291      31265.126      31265.126      3073.0679      3073.0679    
     60000  -13480.839     -13480.839     -13549.663     -13549.663      266.35589      266.35589      31259.103      31259.103      3247.567       3247.567     
Loop time of 21.7459 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.973 ns/day, 6.041 hours/ns, 45.986 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.664     | 21.664     | 21.664     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015076   | 0.015076   | 0.015076   |   0.0 |  0.07
Output  | 0.00010533 | 0.00010533 | 0.00010533 |   0.0 |  0.00
Modify  | 0.061965   | 0.061965   | 0.061965   |   0.0 |  0.28
Other   |            | 0.005237   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134478 ave      134478 max      134478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134478
Ave neighs/atom = 67.239
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.908123662004, Press = -0.485320276844908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13480.839     -13480.839     -13549.663     -13549.663      266.35589      266.35589      31259.103      31259.103      3247.567       3247.567     
     61000  -13475.443     -13475.443     -13548.095     -13548.095      281.16785      281.16785      31277.084      31277.084      1908.2101      1908.2101    
Loop time of 21.6777 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.986 ns/day, 6.022 hours/ns, 46.130 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.596     | 21.596     | 21.596     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014856   | 0.014856   | 0.014856   |   0.0 |  0.07
Output  | 3.5156e-05 | 3.5156e-05 | 3.5156e-05 |   0.0 |  0.00
Modify  | 0.061622   | 0.061622   | 0.061622   |   0.0 |  0.28
Other   |            | 0.005267   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134328 ave      134328 max      134328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134328
Ave neighs/atom = 67.164
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.898139330148, Press = -0.332207916238219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13475.443     -13475.443     -13548.095     -13548.095      281.16785      281.16785      31277.084      31277.084      1908.2101      1908.2101    
     62000  -13479.759     -13479.759     -13549.035     -13549.035      268.10615      268.10615      31287.014      31287.014      869.57829      869.57829    
Loop time of 21.6896 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.983 ns/day, 6.025 hours/ns, 46.105 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.608     | 21.608     | 21.608     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.07
Output  | 4.1438e-05 | 4.1438e-05 | 4.1438e-05 |   0.0 |  0.00
Modify  | 0.06172    | 0.06172    | 0.06172    |   0.0 |  0.28
Other   |            | 0.005271   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134576 ave      134576 max      134576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134576
Ave neighs/atom = 67.288
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857214639858, Press = -0.340963198954273
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13479.759     -13479.759     -13549.035     -13549.035      268.10615      268.10615      31287.014      31287.014      869.57829      869.57829    
     63000  -13475.924     -13475.924     -13547.067     -13547.067      275.33279      275.33279      31306.676      31306.676     -334.83799     -334.83799    
Loop time of 21.7099 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.980 ns/day, 6.031 hours/ns, 46.062 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.628     | 21.628     | 21.628     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014825   | 0.014825   | 0.014825   |   0.0 |  0.07
Output  | 4.1878e-05 | 4.1878e-05 | 4.1878e-05 |   0.0 |  0.00
Modify  | 0.061499   | 0.061499   | 0.061499   |   0.0 |  0.28
Other   |            | 0.005249   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134268 ave      134268 max      134268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134268
Ave neighs/atom = 67.134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.826680130895, Press = -0.420274848140574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13475.924     -13475.924     -13547.067     -13547.067      275.33279      275.33279      31306.676      31306.676     -334.83799     -334.83799    
     64000  -13479.524     -13479.524     -13549.313     -13549.313      270.0933       270.0933       31301.814      31301.814     -347.3275      -347.3275     
Loop time of 21.6625 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.988 ns/day, 6.017 hours/ns, 46.163 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.581     | 21.581     | 21.581     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014893   | 0.014893   | 0.014893   |   0.0 |  0.07
Output  | 4.0295e-05 | 4.0295e-05 | 4.0295e-05 |   0.0 |  0.00
Modify  | 0.061601   | 0.061601   | 0.061601   |   0.0 |  0.28
Other   |            | 0.005243   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134266 ave      134266 max      134266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134266
Ave neighs/atom = 67.133
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.808269933703, Press = -0.672207142740465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13479.524     -13479.524     -13549.313     -13549.313      270.0933       270.0933       31301.814      31301.814     -347.3275      -347.3275     
     65000  -13475.2       -13475.2       -13545.189     -13545.189      270.86145      270.86145      31302.505      31302.505      125.5756       125.5756     
Loop time of 21.601 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.000 ns/day, 6.000 hours/ns, 46.294 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.519     | 21.519     | 21.519     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014875   | 0.014875   | 0.014875   |   0.0 |  0.07
Output  | 3.0006e-05 | 3.0006e-05 | 3.0006e-05 |   0.0 |  0.00
Modify  | 0.061682   | 0.061682   | 0.061682   |   0.0 |  0.29
Other   |            | 0.005245   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134222 ave      134222 max      134222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134222
Ave neighs/atom = 67.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.819684841292, Press = -0.682926945278947
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13475.2       -13475.2       -13545.189     -13545.189      270.86145      270.86145      31302.505      31302.505      125.5756       125.5756     
     66000  -13478.782     -13478.782     -13548.296     -13548.296      269.02599      269.02599      31296.281      31296.281      271.76977      271.76977    
Loop time of 21.6249 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.995 ns/day, 6.007 hours/ns, 46.243 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.543     | 21.543     | 21.543     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014867   | 0.014867   | 0.014867   |   0.0 |  0.07
Output  | 3.0608e-05 | 3.0608e-05 | 3.0608e-05 |   0.0 |  0.00
Modify  | 0.061544   | 0.061544   | 0.061544   |   0.0 |  0.28
Other   |            | 0.005247   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134270 ave      134270 max      134270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134270
Ave neighs/atom = 67.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.8350333591, Press = -0.696144490018724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13478.782     -13478.782     -13548.296     -13548.296      269.02599      269.02599      31296.281      31296.281      271.76977      271.76977    
     67000  -13476.609     -13476.609     -13547.635     -13547.635      274.88062      274.88062      31300.012      31300.012      102.60632      102.60632    
Loop time of 21.6472 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.991 ns/day, 6.013 hours/ns, 46.195 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.565     | 21.565     | 21.565     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.07
Output  | 4.4323e-05 | 4.4323e-05 | 4.4323e-05 |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.28
Other   |            | 0.005252   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134136 ave      134136 max      134136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134136
Ave neighs/atom = 67.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 = 272.83316740154, Press = -0.644464111321826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13476.609     -13476.609     -13547.635     -13547.635      274.88062      274.88062      31300.012      31300.012      102.60632      102.60632    
     68000  -13476.553     -13476.553     -13548.233     -13548.233      277.41091      277.41091      31309.269      31309.269     -607.80747     -607.80747    
Loop time of 21.6356 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.993 ns/day, 6.010 hours/ns, 46.220 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.554     | 21.554     | 21.554     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014887   | 0.014887   | 0.014887   |   0.0 |  0.07
Output  | 2.9856e-05 | 2.9856e-05 | 2.9856e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.28
Other   |            | 0.005244   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133954 ave      133954 max      133954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133954
Ave neighs/atom = 66.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.850931767116, Press = -0.861758698084518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13476.553     -13476.553     -13548.233     -13548.233      277.41091      277.41091      31309.269      31309.269     -607.80747     -607.80747    
     69000  -13473.34      -13473.34      -13544.987     -13544.987      277.28416      277.28416      31314.212      31314.212     -627.13215     -627.13215    
Loop time of 21.7967 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.964 ns/day, 6.055 hours/ns, 45.878 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.715     | 21.715     | 21.715     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015014   | 0.015014   | 0.015014   |   0.0 |  0.07
Output  | 4.4173e-05 | 4.4173e-05 | 4.4173e-05 |   0.0 |  0.00
Modify  | 0.061935   | 0.061935   | 0.061935   |   0.0 |  0.28
Other   |            | 0.005209   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133918 ave      133918 max      133918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133918
Ave neighs/atom = 66.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.862461813662, Press = -1.01826004710697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13473.34      -13473.34      -13544.987     -13544.987      277.28416      277.28416      31314.212      31314.212     -627.13215     -627.13215    
     70000  -13478.127     -13478.127     -13549.92      -13549.92       277.84709      277.84709      31319.348      31319.348     -1834.6124     -1834.6124    
Loop time of 21.6568 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.016 hours/ns, 46.175 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.575     | 21.575     | 21.575     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.07
Output  | 4.1849e-05 | 4.1849e-05 | 4.1849e-05 |   0.0 |  0.00
Modify  | 0.061703   | 0.061703   | 0.061703   |   0.0 |  0.28
Other   |            | 0.005265   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134190 ave      134190 max      134190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134190
Ave neighs/atom = 67.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.903794545059, Press = -1.38532232151154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13478.127     -13478.127     -13549.92      -13549.92       277.84709      277.84709      31319.348      31319.348     -1834.6124     -1834.6124    
     71000  -13475.289     -13475.289     -13546.411     -13546.411      275.25052      275.25052      31319.073      31319.073     -1235.0393     -1235.0393    
Loop time of 21.5836 on 1 procs for 1000 steps with 2000 atoms

Performance: 4.003 ns/day, 5.995 hours/ns, 46.331 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.502     | 21.502     | 21.502     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014898   | 0.014898   | 0.014898   |   0.0 |  0.07
Output  | 3.8873e-05 | 3.8873e-05 | 3.8873e-05 |   0.0 |  0.00
Modify  | 0.061587   | 0.061587   | 0.061587   |   0.0 |  0.29
Other   |            | 0.005269   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       133820 ave      133820 max      133820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133820
Ave neighs/atom = 66.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.922447749394, Press = -1.69993345271239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13475.289     -13475.289     -13546.411     -13546.411      275.25052      275.25052      31319.073      31319.073     -1235.0393     -1235.0393    
     72000  -13478.32      -13478.32      -13546.681     -13546.681      264.56456      264.56456      31302.127      31302.127      21.345891      21.345891    
Loop time of 21.7798 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.967 ns/day, 6.050 hours/ns, 45.914 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.698     | 21.698     | 21.698     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.07
Output  | 4.3221e-05 | 4.3221e-05 | 4.3221e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.28
Other   |            | 0.0052     |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134134 ave      134134 max      134134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134134
Ave neighs/atom = 67.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 = 272.943934783449, Press = -1.65912024130938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13478.32      -13478.32      -13546.681     -13546.681      264.56456      264.56456      31302.127      31302.127      21.345891      21.345891    
     73000  -13475.621     -13475.621     -13548.665     -13548.665      282.68846      282.68846      31290.038      31290.038      896.12527      896.12527    
Loop time of 21.7182 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.978 ns/day, 6.033 hours/ns, 46.044 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.636     | 21.636     | 21.636     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.07
Output  | 3.6438e-05 | 3.6438e-05 | 3.6438e-05 |   0.0 |  0.00
Modify  | 0.061717   | 0.061717   | 0.061717   |   0.0 |  0.28
Other   |            | 0.005282   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134254 ave      134254 max      134254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134254
Ave neighs/atom = 67.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.978189966945, Press = -1.38433931845957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13475.621     -13475.621     -13548.665     -13548.665      282.68846      282.68846      31290.038      31290.038      896.12527      896.12527    
     74000  -13478.408     -13478.408     -13549.24      -13549.24       274.12782      274.12782      31289.971      31289.971      729.58306      729.58306    
Loop time of 21.6369 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.993 ns/day, 6.010 hours/ns, 46.217 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.555     | 21.555     | 21.555     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.07
Output  | 4.0657e-05 | 4.0657e-05 | 4.0657e-05 |   0.0 |  0.00
Modify  | 0.061632   | 0.061632   | 0.061632   |   0.0 |  0.28
Other   |            | 0.00525    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134078 ave      134078 max      134078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134078
Ave neighs/atom = 67.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.990819145276, Press = -0.977766209953685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13478.408     -13478.408     -13549.24      -13549.24       274.12782      274.12782      31289.971      31289.971      729.58306      729.58306    
     75000  -13476.165     -13476.165     -13549.185     -13549.185      282.59362      282.59362      31288.026      31288.026      1098.5272      1098.5272    
Loop time of 21.6417 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.992 ns/day, 6.012 hours/ns, 46.207 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.56      | 21.56      | 21.56      |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01509    | 0.01509    | 0.01509    |   0.0 |  0.07
Output  | 3.0397e-05 | 3.0397e-05 | 3.0397e-05 |   0.0 |  0.00
Modify  | 0.061541   | 0.061541   | 0.061541   |   0.0 |  0.28
Other   |            | 0.005227   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134184 ave      134184 max      134184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134184
Ave neighs/atom = 67.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 = 273.000709266113, Press = -0.882195695301706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13476.165     -13476.165     -13549.185     -13549.185      282.59362      282.59362      31288.026      31288.026      1098.5272      1098.5272    
     76000  -13476.169     -13476.169     -13546.892     -13546.892      273.70315      273.70315      31283.432      31283.432      1552.1694      1552.1694    
Loop time of 21.6545 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.990 ns/day, 6.015 hours/ns, 46.180 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.573     | 21.573     | 21.573     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014872   | 0.014872   | 0.014872   |   0.0 |  0.07
Output  | 4.1087e-05 | 4.1087e-05 | 4.1087e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.28
Other   |            | 0.005245   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134054 ave      134054 max      134054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134054
Ave neighs/atom = 67.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.991480558829, Press = -0.7044979609379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13476.169     -13476.169     -13546.892     -13546.892      273.70315      273.70315      31283.432      31283.432      1552.1694      1552.1694    
     77000  -13478.763     -13478.763     -13549.114     -13549.114      272.26522      272.26522      31278.341      31278.341      1740.7775      1740.7775    
Loop time of 21.6439 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.992 ns/day, 6.012 hours/ns, 46.202 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.562     | 21.562     | 21.562     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01486    | 0.01486    | 0.01486    |   0.0 |  0.07
Output  | 3.0066e-05 | 3.0066e-05 | 3.0066e-05 |   0.0 |  0.00
Modify  | 0.06157    | 0.06157    | 0.06157    |   0.0 |  0.28
Other   |            | 0.005243   |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134534 ave      134534 max      134534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134534
Ave neighs/atom = 67.267
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.99868103389, Press = -0.510506485262753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13478.763     -13478.763     -13549.114     -13549.114      272.26522      272.26522      31278.341      31278.341      1740.7775      1740.7775    
     78000  -13475.932     -13475.932     -13546.429     -13546.429      272.83198      272.83198      31278.622      31278.622      2038.8565      2038.8565    
Loop time of 21.6705 on 1 procs for 1000 steps with 2000 atoms

Performance: 3.987 ns/day, 6.020 hours/ns, 46.146 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 21.589     | 21.589     | 21.589     |   0.0 | 99.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014899   | 0.014899   | 0.014899   |   0.0 |  0.07
Output  | 3.6298e-05 | 3.6298e-05 | 3.6298e-05 |   0.0 |  0.00
Modify  | 0.061543   | 0.061543   | 0.061543   |   0.0 |  0.28
Other   |            | 0.00524    |            |       |  0.02

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134352 ave      134352 max      134352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134352
Ave neighs/atom = 67.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
31301.0606874976

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0