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

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

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

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

kim_interactions Fe

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

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


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23483.2330864207 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_343168101490_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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8494.3364     -8494.3364     -8580.4194     -8580.4194      333.15         333.15         23483.233      23483.233      3915.4474      3915.4474    
      1000  -8403.4985     -8403.4985     -8486.216      -8486.216       320.12522      320.12522      23777.382      23777.382     -749.77178     -749.77178    
Loop time of 53.9128 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.603 ns/day, 14.976 hours/ns, 18.548 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    | 53.831     | 53.831     | 53.831     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01534    | 0.01534    | 0.01534    |   0.0 |  0.03
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.060353   | 0.060353   | 0.060353   |   0.0 |  0.11
Other   |            | 0.005644   |            |       |  0.01

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

Total # of neighbors = 176000
Ave neighs/atom = 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 = 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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8403.4985     -8403.4985     -8486.216      -8486.216       320.12522      320.12522      23777.382      23777.382     -749.77178     -749.77178    
      2000  -8404.4487     -8404.4487     -8490.2147     -8490.2147      331.92305      331.92305      23790.525      23790.525     -2120.9554     -2120.9554    
Loop time of 58.7089 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.472 ns/day, 16.308 hours/ns, 17.033 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.629     | 58.629     | 58.629     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.03
Output  | 4.4314e-05 | 4.4314e-05 | 4.4314e-05 |   0.0 |  0.00
Modify  | 0.059517   | 0.059517   | 0.059517   |   0.0 |  0.10
Other   |            | 0.005374   |            |       |  0.01

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

Total # of neighbors = 189506
Ave neighs/atom = 94.753
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8404.4487     -8404.4487     -8490.2147     -8490.2147      331.92305      331.92305      23790.525      23790.525     -2120.9554     -2120.9554    
      3000  -8405.3519     -8405.3519     -8485.8042     -8485.8042      311.35863      311.35863      23736.039      23736.039      2212.3246      2212.3246    
Loop time of 58.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.319 hours/ns, 17.021 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.67      | 58.67      | 58.67      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014968   | 0.014968   | 0.014968   |   0.0 |  0.03
Output  | 4.0086e-05 | 4.0086e-05 | 4.0086e-05 |   0.0 |  0.00
Modify  | 0.059466   | 0.059466   | 0.059466   |   0.0 |  0.10
Other   |            | 0.005345   |            |       |  0.01

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

Total # of neighbors = 189554
Ave neighs/atom = 94.777
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8405.3519     -8405.3519     -8485.8042     -8485.8042      311.35863      311.35863      23736.039      23736.039      2212.3246      2212.3246    
      4000  -8403.5435     -8403.5435     -8490.1229     -8490.1229      335.07103      335.07103      23736.469      23736.469      1629.6554      1629.6554    
Loop time of 58.9385 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.372 hours/ns, 16.967 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    | 58.859     | 58.859     | 58.859     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.8853e-05 | 3.8853e-05 | 3.8853e-05 |   0.0 |  0.00
Modify  | 0.059395   | 0.059395   | 0.059395   |   0.0 |  0.10
Other   |            | 0.005308   |            |       |  0.01

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

Total # of neighbors = 190364
Ave neighs/atom = 95.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8403.5435     -8403.5435     -8490.1229     -8490.1229      335.07103      335.07103      23736.469      23736.469      1629.6554      1629.6554    
      5000  -8405.4636     -8405.4636     -8492.4821     -8492.4821      336.77059      336.77059      23778.04       23778.04      -1464.3752     -1464.3752    
Loop time of 58.9644 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.465 ns/day, 16.379 hours/ns, 16.959 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    | 58.884     | 58.884     | 58.884     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014994   | 0.014994   | 0.014994   |   0.0 |  0.03
Output  | 3.3022e-05 | 3.3022e-05 | 3.3022e-05 |   0.0 |  0.00
Modify  | 0.059692   | 0.059692   | 0.059692   |   0.0 |  0.10
Other   |            | 0.005352   |            |       |  0.01

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

Total # of neighbors = 190534
Ave neighs/atom = 95.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 = 332.212559358749, Press = -193.227854652749
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8405.4636     -8405.4636     -8492.4821     -8492.4821      336.77059      336.77059      23778.04       23778.04      -1464.3752     -1464.3752    
      6000  -8402.8837     -8402.8837     -8493.2524     -8493.2524      349.73634      349.73634      23769.354      23769.354     -911.57706     -911.57706    
Loop time of 58.9543 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.376 hours/ns, 16.962 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.872     | 58.872     | 58.872     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014897   | 0.014897   | 0.014897   |   0.0 |  0.03
Output  | 3.0398e-05 | 3.0398e-05 | 3.0398e-05 |   0.0 |  0.00
Modify  | 0.061742   | 0.061742   | 0.061742   |   0.0 |  0.10
Other   |            | 0.005366   |            |       |  0.01

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

Total # of neighbors = 189740
Ave neighs/atom = 94.87
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.881450622727, Press = 15.2542074399317
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8402.8837     -8402.8837     -8493.2524     -8493.2524      349.73634      349.73634      23769.354      23769.354     -911.57706     -911.57706    
      7000  -8407.1562     -8407.1562     -8492.296      -8492.296       329.49978      329.49978      23749.569      23749.569      466.99012      466.99012    
Loop time of 59.0166 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.464 ns/day, 16.394 hours/ns, 16.944 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    | 58.934     | 58.934     | 58.934     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.03
Output  | 2.9436e-05 | 2.9436e-05 | 2.9436e-05 |   0.0 |  0.00
Modify  | 0.061784   | 0.061784   | 0.061784   |   0.0 |  0.10
Other   |            | 0.005396   |            |       |  0.01

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

Total # of neighbors = 189994
Ave neighs/atom = 94.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 = 332.545764853359, Press = 20.936961613855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8407.1562     -8407.1562     -8492.296      -8492.296       329.49978      329.49978      23749.569      23749.569      466.99012      466.99012    
      8000  -8402.9808     -8402.9808     -8490.2895     -8490.2895      337.89377      337.89377      23724.841      23724.841      2616.9569      2616.9569    
Loop time of 58.956 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.377 hours/ns, 16.962 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    | 58.874     | 58.874     | 58.874     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015021   | 0.015021   | 0.015021   |   0.0 |  0.03
Output  | 3.0387e-05 | 3.0387e-05 | 3.0387e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.10
Other   |            | 0.005388   |            |       |  0.01

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

Total # of neighbors = 190578
Ave neighs/atom = 95.289
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.521670445737, Press = -17.0838442331352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8402.9808     -8402.9808     -8490.2895     -8490.2895      337.89377      337.89377      23724.841      23724.841      2616.9569      2616.9569    
      9000  -8405.7717     -8405.7717     -8489.7817     -8489.7817      325.12714      325.12714      23787.179      23787.179     -1841.2756     -1841.2756    
Loop time of 59.0854 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.462 ns/day, 16.413 hours/ns, 16.925 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    | 59.003     | 59.003     | 59.003     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014911   | 0.014911   | 0.014911   |   0.0 |  0.03
Output  | 2.9766e-05 | 2.9766e-05 | 2.9766e-05 |   0.0 |  0.00
Modify  | 0.061741   | 0.061741   | 0.061741   |   0.0 |  0.10
Other   |            | 0.005364   |            |       |  0.01

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

Total # of neighbors = 191126
Ave neighs/atom = 95.563
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.930065108675, Press = -17.2067305983141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8405.7717     -8405.7717     -8489.7817     -8489.7817      325.12714      325.12714      23787.179      23787.179     -1841.2756     -1841.2756    
     10000  -8405.9593     -8405.9593     -8490.0064     -8490.0064      325.27101      325.27101      23780.96       23780.96      -1520.3313     -1520.3313    
Loop time of 58.7951 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.332 hours/ns, 17.008 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    | 58.713     | 58.713     | 58.713     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014952   | 0.014952   | 0.014952   |   0.0 |  0.03
Output  | 2.9876e-05 | 2.9876e-05 | 2.9876e-05 |   0.0 |  0.00
Modify  | 0.061705   | 0.061705   | 0.061705   |   0.0 |  0.10
Other   |            | 0.005355   |            |       |  0.01

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

Total # of neighbors = 189622
Ave neighs/atom = 94.811
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.952283751035, Press = 10.4168977097016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8405.9593     -8405.9593     -8490.0064     -8490.0064      325.27101      325.27101      23780.96       23780.96      -1520.3313     -1520.3313    
     11000  -8402.1762     -8402.1762     -8490.0677     -8490.0677      340.14931      340.14931      23749.192      23749.192      917.9717       917.9717     
Loop time of 58.7849 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.329 hours/ns, 17.011 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    | 58.703     | 58.703     | 58.703     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.03
Output  | 2.8393e-05 | 2.8393e-05 | 2.8393e-05 |   0.0 |  0.00
Modify  | 0.061729   | 0.061729   | 0.061729   |   0.0 |  0.11
Other   |            | 0.005322   |            |       |  0.01

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

Total # of neighbors = 189708
Ave neighs/atom = 94.854
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.087553137907, Press = 4.66971321136986
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8402.1762     -8402.1762     -8490.0677     -8490.0677      340.14931      340.14931      23749.192      23749.192      917.9717       917.9717     
     12000  -8405.8254     -8405.8254     -8490.0753     -8490.0753      326.05569      326.05569      23752.743      23752.743      523.10379      523.10379    
Loop time of 58.8306 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.342 hours/ns, 16.998 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    | 58.749     | 58.749     | 58.749     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.03
Output  | 2.2152e-05 | 2.2152e-05 | 2.2152e-05 |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.10
Other   |            | 0.005295   |            |       |  0.01

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

Total # of neighbors = 190358
Ave neighs/atom = 95.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 = 331.872157733419, Press = -1.56229244555511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8405.8254     -8405.8254     -8490.0753     -8490.0753      326.05569      326.05569      23752.743      23752.743      523.10379      523.10379    
     13000  -8403.8814     -8403.8814     -8489.3054     -8489.3054      330.59959      330.59959      23764.074      23764.074     -56.804765     -56.804765    
Loop time of 58.8403 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.345 hours/ns, 16.995 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    | 58.758     | 58.758     | 58.758     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014989   | 0.014989   | 0.014989   |   0.0 |  0.03
Output  | 3.3022e-05 | 3.3022e-05 | 3.3022e-05 |   0.0 |  0.00
Modify  | 0.061731   | 0.061731   | 0.061731   |   0.0 |  0.10
Other   |            | 0.005359   |            |       |  0.01

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

Total # of neighbors = 190386
Ave neighs/atom = 95.193
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.04141283002, Press = -1.19591256316832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8403.8814     -8403.8814     -8489.3054     -8489.3054      330.59959      330.59959      23764.074      23764.074     -56.804765     -56.804765    
     14000  -8404.9131     -8404.9131     -8489.9673     -8489.9673      329.1686       329.1686       23767.909      23767.909     -522.55496     -522.55496    
Loop time of 58.8718 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.353 hours/ns, 16.986 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    | 58.79      | 58.79      | 58.79      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014999   | 0.014999   | 0.014999   |   0.0 |  0.03
Output  | 3.2542e-05 | 3.2542e-05 | 3.2542e-05 |   0.0 |  0.00
Modify  | 0.061694   | 0.061694   | 0.061694   |   0.0 |  0.10
Other   |            | 0.005357   |            |       |  0.01

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

Total # of neighbors = 190126
Ave neighs/atom = 95.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.045301137928, Press = -1.88134889672642
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8404.9131     -8404.9131     -8489.9673     -8489.9673      329.1686       329.1686       23767.909      23767.909     -522.55496     -522.55496    
     15000  -8404.7359     -8404.7359     -8491.5589     -8491.5589      336.01404      336.01404      23761.406      23761.406     -188.50308     -188.50308    
Loop time of 58.8279 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.341 hours/ns, 16.999 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    | 58.746     | 58.746     | 58.746     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.03
Output  | 3.3784e-05 | 3.3784e-05 | 3.3784e-05 |   0.0 |  0.00
Modify  | 0.061692   | 0.061692   | 0.061692   |   0.0 |  0.10
Other   |            | 0.005341   |            |       |  0.01

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

Total # of neighbors = 189914
Ave neighs/atom = 94.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.127548303819, Press = 1.0711245348072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8404.7359     -8404.7359     -8491.5589     -8491.5589      336.01404      336.01404      23761.406      23761.406     -188.50308     -188.50308    
     16000  -8403.5549     -8403.5549     -8489.2904     -8489.2904      331.80506      331.80506      23744.583      23744.583      1260.7784      1260.7784    
Loop time of 58.9192 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.366 hours/ns, 16.972 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    | 58.837     | 58.837     | 58.837     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015029   | 0.015029   | 0.015029   |   0.0 |  0.03
Output  | 3.193e-05  | 3.193e-05  | 3.193e-05  |   0.0 |  0.00
Modify  | 0.061648   | 0.061648   | 0.061648   |   0.0 |  0.10
Other   |            | 0.005347   |            |       |  0.01

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

Total # of neighbors = 190324
Ave neighs/atom = 95.162
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.136308019756, Press = -0.395668208193908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8403.5549     -8403.5549     -8489.2904     -8489.2904      331.80506      331.80506      23744.583      23744.583      1260.7784      1260.7784    
     17000  -8406.2188     -8406.2188     -8490.0865     -8490.0865      324.57658      324.57658      23758.454      23758.454      125.86886      125.86886    
Loop time of 58.9231 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.368 hours/ns, 16.971 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.841     | 58.841     | 58.841     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014904   | 0.014904   | 0.014904   |   0.0 |  0.03
Output  | 3.17e-05   | 3.17e-05   | 3.17e-05   |   0.0 |  0.00
Modify  | 0.061741   | 0.061741   | 0.061741   |   0.0 |  0.10
Other   |            | 0.005357   |            |       |  0.01

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

Total # of neighbors = 190434
Ave neighs/atom = 95.217
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.219352035116, Press = -4.01166954084185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8406.2188     -8406.2188     -8490.0865     -8490.0865      324.57658      324.57658      23758.454      23758.454      125.86886      125.86886    
     18000  -8403.1593     -8403.1593     -8488.9756     -8488.9756      332.1181       332.1181       23788.02       23788.02      -1632.5808     -1632.5808    
Loop time of 58.9004 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.361 hours/ns, 16.978 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    | 58.818     | 58.818     | 58.818     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.3032e-05 | 3.3032e-05 | 3.3032e-05 |   0.0 |  0.00
Modify  | 0.06169    | 0.06169    | 0.06169    |   0.0 |  0.10
Other   |            | 0.005348   |            |       |  0.01

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

Total # of neighbors = 190216
Ave neighs/atom = 95.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.233566893047, Press = -1.05228135132567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8403.1593     -8403.1593     -8488.9756     -8488.9756      332.1181       332.1181       23788.02       23788.02      -1632.5808     -1632.5808    
     19000  -8405.1471     -8405.1471     -8492.0439     -8492.0439      336.29959      336.29959      23750.722      23750.722      517.92084      517.92084    
Loop time of 58.8979 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.361 hours/ns, 16.979 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    | 58.816     | 58.816     | 58.816     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 3.197e-05  | 3.197e-05  | 3.197e-05  |   0.0 |  0.00
Modify  | 0.061658   | 0.061658   | 0.061658   |   0.0 |  0.10
Other   |            | 0.005249   |            |       |  0.01

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

Total # of neighbors = 189480
Ave neighs/atom = 94.74
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.397892800034, Press = 5.74342348975742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8405.1471     -8405.1471     -8492.0439     -8492.0439      336.29959      336.29959      23750.722      23750.722      517.92084      517.92084    
     20000  -8401.8152     -8401.8152     -8489.3118     -8489.3118      338.62092      338.62092      23721.544      23721.544      3116.8687      3116.8687    
Loop time of 58.922 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.367 hours/ns, 16.972 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    | 58.84      | 58.84      | 58.84      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.03
Output  | 3.2251e-05 | 3.2251e-05 | 3.2251e-05 |   0.0 |  0.00
Modify  | 0.061685   | 0.061685   | 0.061685   |   0.0 |  0.10
Other   |            | 0.005298   |            |       |  0.01

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

Total # of neighbors = 190534
Ave neighs/atom = 95.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 = 332.63067792558, Press = -2.80213575672358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8401.8152     -8401.8152     -8489.3118     -8489.3118      338.62092      338.62092      23721.544      23721.544      3116.8687      3116.8687    
     21000  -8406.381      -8406.381      -8491.808      -8491.808       330.61107      330.61107      23791.412      23791.412     -2360.3047     -2360.3047    
Loop time of 58.9598 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.465 ns/day, 16.378 hours/ns, 16.961 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    | 58.878     | 58.878     | 58.878     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.03
Output  | 3.2041e-05 | 3.2041e-05 | 3.2041e-05 |   0.0 |  0.00
Modify  | 0.061777   | 0.061777   | 0.061777   |   0.0 |  0.10
Other   |            | 0.005355   |            |       |  0.01

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

Total # of neighbors = 190924
Ave neighs/atom = 95.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.851400120874, Press = -3.13282531090306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8406.381      -8406.381      -8491.808      -8491.808       330.61107      330.61107      23791.412      23791.412     -2360.3047     -2360.3047    
     22000  -8405.2832     -8405.2832     -8491.062      -8491.062       331.97305      331.97305      23777.629      23777.629     -1350.5032     -1350.5032    
Loop time of 58.7846 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.329 hours/ns, 17.011 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    | 58.703     | 58.703     | 58.703     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.03
Output  | 3.2972e-05 | 3.2972e-05 | 3.2972e-05 |   0.0 |  0.00
Modify  | 0.061718   | 0.061718   | 0.061718   |   0.0 |  0.10
Other   |            | 0.005352   |            |       |  0.01

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

Total # of neighbors = 189484
Ave neighs/atom = 94.742
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920361066068, Press = 2.30322815488516
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8405.2832     -8405.2832     -8491.062      -8491.062       331.97305      331.97305      23777.629      23777.629     -1350.5032     -1350.5032    
     23000  -8405.4922     -8405.4922     -8489.2177     -8489.2177      324.02612      324.02612      23721.549      23721.549      2941.0996      2941.0996    
Loop time of 58.9075 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.363 hours/ns, 16.976 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    | 58.826     | 58.826     | 58.826     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.03
Output  | 3.2191e-05 | 3.2191e-05 | 3.2191e-05 |   0.0 |  0.00
Modify  | 0.061586   | 0.061586   | 0.061586   |   0.0 |  0.10
Other   |            | 0.005248   |            |       |  0.01

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

Total # of neighbors = 189766
Ave neighs/atom = 94.883
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.75624366586, Press = 1.51871483840495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8405.4922     -8405.4922     -8489.2177     -8489.2177      324.02612      324.02612      23721.549      23721.549      2941.0996      2941.0996    
     24000  -8404.0982     -8404.0982     -8490.6424     -8490.6424      334.93511      334.93511      23760.675      23760.675     -56.95675      -56.95675     
Loop time of 59.0653 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.407 hours/ns, 16.930 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    | 58.983     | 58.983     | 58.983     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014975   | 0.014975   | 0.014975   |   0.0 |  0.03
Output  | 3.2021e-05 | 3.2021e-05 | 3.2021e-05 |   0.0 |  0.00
Modify  | 0.061628   | 0.061628   | 0.061628   |   0.0 |  0.10
Other   |            | 0.005254   |            |       |  0.01

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

Total # of neighbors = 191208
Ave neighs/atom = 95.604
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.721722124732, Press = -4.28729651883601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8404.0982     -8404.0982     -8490.6424     -8490.6424      334.93511      334.93511      23760.675      23760.675     -56.95675      -56.95675     
     25000  -8405.7854     -8405.7854     -8491.0728     -8491.0728      330.07118      330.07118      23769.474      23769.474     -782.34211     -782.34211    
Loop time of 58.8652 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.351 hours/ns, 16.988 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    | 58.783     | 58.783     | 58.783     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014981   | 0.014981   | 0.014981   |   0.0 |  0.03
Output  | 3.3253e-05 | 3.3253e-05 | 3.3253e-05 |   0.0 |  0.00
Modify  | 0.06155    | 0.06155    | 0.06155    |   0.0 |  0.10
Other   |            | 0.005244   |            |       |  0.01

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

Total # of neighbors = 189986
Ave neighs/atom = 94.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.708161968229, Press = -0.654418996019735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8405.7854     -8405.7854     -8491.0728     -8491.0728      330.07118      330.07118      23769.474      23769.474     -782.34211     -782.34211    
     26000  -8404.2061     -8404.2061     -8492.8162     -8492.8162      342.93032      342.93032      23759.64       23759.64      -267.85096     -267.85096    
Loop time of 58.7876 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.330 hours/ns, 17.010 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    | 58.706     | 58.706     | 58.706     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.03
Output  | 3.3032e-05 | 3.3032e-05 | 3.3032e-05 |   0.0 |  0.00
Modify  | 0.061627   | 0.061627   | 0.061627   |   0.0 |  0.10
Other   |            | 0.00524    |            |       |  0.01

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

Total # of neighbors = 189978
Ave neighs/atom = 94.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.707291469323, Press = 0.306927049270015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8404.2061     -8404.2061     -8492.8162     -8492.8162      342.93032      342.93032      23759.64       23759.64      -267.85096     -267.85096    
     27000  -8406.7605     -8406.7605     -8490.7903     -8490.7903      325.20397      325.20397      23751.308      23751.308      543.55489      543.55489    
Loop time of 59.0211 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.464 ns/day, 16.395 hours/ns, 16.943 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    | 58.939     | 58.939     | 58.939     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.03
Output  | 3.2972e-05 | 3.2972e-05 | 3.2972e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.10
Other   |            | 0.005246   |            |       |  0.01

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

Total # of neighbors = 190452
Ave neighs/atom = 95.226
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.605817018396, Press = -0.559892506852818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8406.7605     -8406.7605     -8490.7903     -8490.7903      325.20397      325.20397      23751.308      23751.308      543.55489      543.55489    
     28000  -8401.9776     -8401.9776     -8488.6694     -8488.6694      335.50639      335.50639      23788.249      23788.249     -1504.6283     -1504.6283    
Loop time of 58.8918 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.359 hours/ns, 16.980 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    | 58.81      | 58.81      | 58.81      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.03
Output  | 3.3703e-05 | 3.3703e-05 | 3.3703e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.10
Other   |            | 0.00527    |            |       |  0.01

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

Total # of neighbors = 190464
Ave neighs/atom = 95.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 = 332.636012609133, Press = -1.81515805389233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8401.9776     -8401.9776     -8488.6694     -8488.6694      335.50639      335.50639      23788.249      23788.249     -1504.6283     -1504.6283    
     29000  -8408.4475     -8408.4475     -8492.7509     -8492.7509      326.26257      326.26257      23750.838      23750.838      209.30211      209.30211    
Loop time of 58.852 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.348 hours/ns, 16.992 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    | 58.77      | 58.77      | 58.77      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.03
Output  | 3.215e-05  | 3.215e-05  | 3.215e-05  |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.10
Other   |            | 0.005239   |            |       |  0.01

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

Total # of neighbors = 189652
Ave neighs/atom = 94.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.621798917687, Press = 2.20848852463204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8408.4475     -8408.4475     -8492.7509     -8492.7509      326.26257      326.26257      23750.838      23750.838      209.30211      209.30211    
     30000  -8402.1647     -8402.1647     -8489.1112     -8489.1112      336.49175      336.49175      23725.51       23725.51       2859.1633      2859.1633    
Loop time of 58.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.368 hours/ns, 16.970 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    | 58.844     | 58.844     | 58.844     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.03
Output  | 3.2411e-05 | 3.2411e-05 | 3.2411e-05 |   0.0 |  0.00
Modify  | 0.061678   | 0.061678   | 0.061678   |   0.0 |  0.10
Other   |            | 0.005292   |            |       |  0.01

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

Total # of neighbors = 190596
Ave neighs/atom = 95.298
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.543182975111, Press = -1.37985894424972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8402.1647     -8402.1647     -8489.1112     -8489.1112      336.49175      336.49175      23725.51       23725.51       2859.1633      2859.1633    
     31000  -8406.5041     -8406.5041     -8492.9076     -8492.9076      334.39046      334.39046      23784.73       23784.73      -1986.6202     -1986.6202    
Loop time of 59.0476 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.402 hours/ns, 16.935 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    | 58.966     | 58.966     | 58.966     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015017   | 0.015017   | 0.015017   |   0.0 |  0.03
Output  | 3.2231e-05 | 3.2231e-05 | 3.2231e-05 |   0.0 |  0.00
Modify  | 0.061728   | 0.061728   | 0.061728   |   0.0 |  0.10
Other   |            | 0.00535    |            |       |  0.01

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

Total # of neighbors = 190966
Ave neighs/atom = 95.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.464864955195, Press = -4.00699539190536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8406.5041     -8406.5041     -8492.9076     -8492.9076      334.39046      334.39046      23784.73       23784.73      -1986.6202     -1986.6202    
     32000  -8402.3026     -8402.3026     -8488.8455     -8488.8455      334.92964      334.92964      23790.76       23790.76      -1711.5505     -1711.5505    
Loop time of 58.8317 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.342 hours/ns, 16.998 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    | 58.75      | 58.75      | 58.75      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.03
Output  | 3.2942e-05 | 3.2942e-05 | 3.2942e-05 |   0.0 |  0.00
Modify  | 0.061675   | 0.061675   | 0.061675   |   0.0 |  0.10
Other   |            | 0.005324   |            |       |  0.01

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

Total # of neighbors = 189904
Ave neighs/atom = 94.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.506930049333, Press = 1.5951767619712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8402.3026     -8402.3026     -8488.8455     -8488.8455      334.92964      334.92964      23790.76       23790.76      -1711.5505     -1711.5505    
     33000  -8403.3188     -8403.3188     -8490.0717     -8490.0717      335.74269      335.74269      23749.889      23749.889      1035.2061      1035.2061    
Loop time of 58.8029 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.334 hours/ns, 17.006 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.721     | 58.721     | 58.721     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015032   | 0.015032   | 0.015032   |   0.0 |  0.03
Output  | 4.3613e-05 | 4.3613e-05 | 4.3613e-05 |   0.0 |  0.00
Modify  | 0.061636   | 0.061636   | 0.061636   |   0.0 |  0.10
Other   |            | 0.005298   |            |       |  0.01

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

Total # of neighbors = 189458
Ave neighs/atom = 94.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.527689943896, Press = 0.36874869776967
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8403.3188     -8403.3188     -8490.0717     -8490.0717      335.74269      335.74269      23749.889      23749.889      1035.2061      1035.2061    
     34000  -8406.671      -8406.671      -8493.1222     -8493.1222      334.57531      334.57531      23753.128      23753.128      159.61931      159.61931    
Loop time of 58.9594 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.465 ns/day, 16.378 hours/ns, 16.961 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    | 58.877     | 58.877     | 58.877     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.03
Output  | 4.0075e-05 | 4.0075e-05 | 4.0075e-05 |   0.0 |  0.00
Modify  | 0.06166    | 0.06166    | 0.06166    |   0.0 |  0.10
Other   |            | 0.005377   |            |       |  0.01

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

Total # of neighbors = 190576
Ave neighs/atom = 95.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 = 332.540596827232, Press = -0.736022532595699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8406.671      -8406.671      -8493.1222     -8493.1222      334.57531      334.57531      23753.128      23753.128      159.61931      159.61931    
     35000  -8402.858      -8402.858      -8488.6756     -8488.6756      332.12276      332.12276      23773.482      23773.482     -607.31883     -607.31883    
Loop time of 58.8594 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.350 hours/ns, 16.990 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    | 58.778     | 58.778     | 58.778     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.03
Output  | 4.0897e-05 | 4.0897e-05 | 4.0897e-05 |   0.0 |  0.00
Modify  | 0.06157    | 0.06157    | 0.06157    |   0.0 |  0.10
Other   |            | 0.005281   |            |       |  0.01

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

Total # of neighbors = 190442
Ave neighs/atom = 95.221
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.631630064806, Press = -1.62668618230766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8402.858      -8402.858      -8488.6756     -8488.6756      332.12276      332.12276      23773.482      23773.482     -607.31883     -607.31883    
     36000  -8405.6382     -8405.6382     -8491.7235     -8491.7235      333.1587       333.1587       23788.974      23788.974     -2195.3645     -2195.3645    
Loop time of 58.8913 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.359 hours/ns, 16.980 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    | 58.809     | 58.809     | 58.809     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 3.8763e-05 | 3.8763e-05 | 3.8763e-05 |   0.0 |  0.00
Modify  | 0.061625   | 0.061625   | 0.061625   |   0.0 |  0.10
Other   |            | 0.005295   |            |       |  0.01

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

Total # of neighbors = 189922
Ave neighs/atom = 94.961
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.626486861835, Press = 1.39845478595398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8405.6382     -8405.6382     -8491.7235     -8491.7235      333.1587       333.1587       23788.974      23788.974     -2195.3645     -2195.3645    
     37000  -8404.7163     -8404.7163     -8489.3747     -8489.3747      327.63664      327.63664      23711.221      23711.221      3669.2424      3669.2424    
Loop time of 58.8468 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.346 hours/ns, 16.993 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    | 58.765     | 58.765     | 58.765     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014967   | 0.014967   | 0.014967   |   0.0 |  0.03
Output  | 4.0526e-05 | 4.0526e-05 | 4.0526e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.10
Other   |            | 0.005296   |            |       |  0.01

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

Total # of neighbors = 189426
Ave neighs/atom = 94.713
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.701758164924, Press = 0.919103926651684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8404.7163     -8404.7163     -8489.3747     -8489.3747      327.63664      327.63664      23711.221      23711.221      3669.2424      3669.2424    
     38000  -8404.6171     -8404.6171     -8489.2943     -8489.2943      327.70936      327.70936      23757.534      23757.534      440.61794      440.61794    
Loop time of 59.0435 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.401 hours/ns, 16.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    | 58.962     | 58.962     | 58.962     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.03
Output  | 3.8042e-05 | 3.8042e-05 | 3.8042e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.10
Other   |            | 0.005313   |            |       |  0.01

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

Total # of neighbors = 191292
Ave neighs/atom = 95.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.764669659576, Press = -2.70149705261306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8404.6171     -8404.6171     -8489.2943     -8489.2943      327.70936      327.70936      23757.534      23757.534      440.61794      440.61794    
     39000  -8401.1024     -8401.1024     -8490.6781     -8490.6781      346.66724      346.66724      23795.573      23795.573     -2319.0852     -2319.0852    
Loop time of 58.8872 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.358 hours/ns, 16.982 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    | 58.805     | 58.805     | 58.805     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014934   | 0.014934   | 0.014934   |   0.0 |  0.03
Output  | 4.1258e-05 | 4.1258e-05 | 4.1258e-05 |   0.0 |  0.00
Modify  | 0.061668   | 0.061668   | 0.061668   |   0.0 |  0.10
Other   |            | 0.005338   |            |       |  0.01

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

Total # of neighbors = 190216
Ave neighs/atom = 95.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.824494066209, Press = -0.815068535554259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8401.1024     -8401.1024     -8490.6781     -8490.6781      346.66724      346.66724      23795.573      23795.573     -2319.0852     -2319.0852    
     40000  -8405.1033     -8405.1033     -8490.9952     -8490.9952      332.41036      332.41036      23756.636      23756.636      181.80889      181.80889    
Loop time of 58.7756 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.327 hours/ns, 17.014 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    | 58.694     | 58.694     | 58.694     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 4.0467e-05 | 4.0467e-05 | 4.0467e-05 |   0.0 |  0.00
Modify  | 0.061641   | 0.061641   | 0.061641   |   0.0 |  0.10
Other   |            | 0.005326   |            |       |  0.01

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

Total # of neighbors = 189406
Ave neighs/atom = 94.703
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.791995188199, Press = 0.988012233870782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8405.1033     -8405.1033     -8490.9952     -8490.9952      332.41036      332.41036      23756.636      23756.636      181.80889      181.80889    
     41000  -8402.1598     -8402.1598     -8490.6765     -8490.6765      342.569        342.569        23744.67       23744.67       1160.1805      1160.1805    
Loop time of 58.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.356 hours/ns, 16.984 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.798     | 58.798     | 58.798     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.03
Output  | 4.0667e-05 | 4.0667e-05 | 4.0667e-05 |   0.0 |  0.00
Modify  | 0.061629   | 0.061629   | 0.061629   |   0.0 |  0.10
Other   |            | 0.005312   |            |       |  0.01

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

Total # of neighbors = 190014
Ave neighs/atom = 95.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.742231221252, Press = -1.44169385746818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8402.1598     -8402.1598     -8490.6765     -8490.6765      342.569        342.569        23744.67       23744.67       1160.1805      1160.1805    
     42000  -8400.0627     -8400.0627     -8487.196      -8487.196       337.2149       337.2149       23783.558      23783.558     -953.94838     -953.94838    
Loop time of 58.8007 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.334 hours/ns, 17.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    | 58.719     | 58.719     | 58.719     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 4.1849e-05 | 4.1849e-05 | 4.1849e-05 |   0.0 |  0.00
Modify  | 0.061657   | 0.061657   | 0.061657   |   0.0 |  0.10
Other   |            | 0.005345   |            |       |  0.01

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

Total # of neighbors = 190222
Ave neighs/atom = 95.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 = 332.736137480157, Press = -0.868701188330729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8400.0627     -8400.0627     -8487.196      -8487.196       337.2149       337.2149       23783.558      23783.558     -953.94838     -953.94838    
     43000  -8405.3438     -8405.3438     -8489.7801     -8489.7801      326.77732      326.77732      23769.649      23769.649     -624.05213     -624.05213    
Loop time of 58.8551 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.349 hours/ns, 16.991 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    | 58.773     | 58.773     | 58.773     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014966   | 0.014966   | 0.014966   |   0.0 |  0.03
Output  | 4.1027e-05 | 4.1027e-05 | 4.1027e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.10
Other   |            | 0.005297   |            |       |  0.01

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

Total # of neighbors = 189624
Ave neighs/atom = 94.812
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.781018844056, Press = 0.325589402959146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8405.3438     -8405.3438     -8489.7801     -8489.7801      326.77732      326.77732      23769.649      23769.649     -624.05213     -624.05213    
     44000  -8401.3125     -8401.3125     -8488.1781     -8488.1781      336.17878      336.17878      23745.716      23745.716      1488.2985      1488.2985    
Loop time of 58.8426 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.345 hours/ns, 16.994 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    | 58.761     | 58.761     | 58.761     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.03
Output  | 4.241e-05  | 4.241e-05  | 4.241e-05  |   0.0 |  0.00
Modify  | 0.061643   | 0.061643   | 0.061643   |   0.0 |  0.10
Other   |            | 0.00529    |            |       |  0.01

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

Total # of neighbors = 189878
Ave neighs/atom = 94.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.841552310373, Press = 0.0777983015011498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8401.3125     -8401.3125     -8488.1781     -8488.1781      336.17878      336.17878      23745.716      23745.716      1488.2985      1488.2985    
     45000  -8406.5314     -8406.5314     -8491.3749     -8491.3749      328.35279      328.35279      23750.646      23750.646      537.78429      537.78429    
Loop time of 58.8193 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.339 hours/ns, 17.001 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    | 58.737     | 58.737     | 58.737     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01494    | 0.01494    | 0.01494    |   0.0 |  0.03
Output  | 8.9038e-05 | 8.9038e-05 | 8.9038e-05 |   0.0 |  0.00
Modify  | 0.061585   | 0.061585   | 0.061585   |   0.0 |  0.10
Other   |            | 0.005302   |            |       |  0.01

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

Total # of neighbors = 190296
Ave neighs/atom = 95.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.906041170883, Press = -1.48771950125263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8406.5314     -8406.5314     -8491.3749     -8491.3749      328.35279      328.35279      23750.646      23750.646      537.78429      537.78429    
     46000  -8401.2948     -8401.2948     -8489.268      -8489.268       340.46543      340.46543      23816.088      23816.088     -3472.3144     -3472.3144    
Loop time of 58.9483 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.375 hours/ns, 16.964 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    | 58.866     | 58.866     | 58.866     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014902   | 0.014902   | 0.014902   |   0.0 |  0.03
Output  | 4.0857e-05 | 4.0857e-05 | 4.0857e-05 |   0.0 |  0.00
Modify  | 0.061879   | 0.061879   | 0.061879   |   0.0 |  0.10
Other   |            | 0.005297   |            |       |  0.01

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

Total # of neighbors = 190442
Ave neighs/atom = 95.221
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.946425693693, Press = -0.962581536904593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8401.2948     -8401.2948     -8489.268      -8489.268       340.46543      340.46543      23816.088      23816.088     -3472.3144     -3472.3144    
     47000  -8402.3241     -8402.3241     -8488.1721     -8488.1721      332.24072      332.24072      23758.63       23758.63       568.00197      568.00197    
Loop time of 58.7585 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.322 hours/ns, 17.019 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.676     | 58.676     | 58.676     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.03
Output  | 4.0366e-05 | 4.0366e-05 | 4.0366e-05 |   0.0 |  0.00
Modify  | 0.061669   | 0.061669   | 0.061669   |   0.0 |  0.10
Other   |            | 0.005349   |            |       |  0.01

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

Total # of neighbors = 188906
Ave neighs/atom = 94.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.944795693464, Press = 2.30089612019351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8402.3241     -8402.3241     -8488.1721     -8488.1721      332.24072      332.24072      23758.63       23758.63       568.00197      568.00197    
     48000  -8409.2044     -8409.2044     -8492.2525     -8492.2525      321.40478      321.40478      23719.357      23719.357      2361.2714      2361.2714    
Loop time of 58.9269 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.369 hours/ns, 16.970 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    | 58.845     | 58.845     | 58.845     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014897   | 0.014897   | 0.014897   |   0.0 |  0.03
Output  | 4.0697e-05 | 4.0697e-05 | 4.0697e-05 |   0.0 |  0.00
Modify  | 0.061699   | 0.061699   | 0.061699   |   0.0 |  0.10
Other   |            | 0.005345   |            |       |  0.01

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

Total # of neighbors = 190150
Ave neighs/atom = 95.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913453363904, Press = -0.799454689874178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8409.2044     -8409.2044     -8492.2525     -8492.2525      321.40478      321.40478      23719.357      23719.357      2361.2714      2361.2714    
     49000  -8403.2503     -8403.2503     -8489.4268     -8489.4268      333.51182      333.51182      23775.389      23775.389     -859.08361     -859.08361    
Loop time of 59.0679 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.408 hours/ns, 16.930 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    | 58.986     | 58.986     | 58.986     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.03
Output  | 3.4755e-05 | 3.4755e-05 | 3.4755e-05 |   0.0 |  0.00
Modify  | 0.061565   | 0.061565   | 0.061565   |   0.0 |  0.10
Other   |            | 0.005322   |            |       |  0.01

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

Total # of neighbors = 190986
Ave neighs/atom = 95.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.880834017638, Press = -1.06579268225765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8403.2503     -8403.2503     -8489.4268     -8489.4268      333.51182      333.51182      23775.389      23775.389     -859.08361     -859.08361    
     50000  -8405.5374     -8405.5374     -8491.9422     -8491.9422      334.39557      334.39557      23775.471      23775.471     -1432.3836     -1432.3836    
Loop time of 58.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.335 hours/ns, 17.005 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    | 58.723     | 58.723     | 58.723     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014942   | 0.014942   | 0.014942   |   0.0 |  0.03
Output  | 3.7791e-05 | 3.7791e-05 | 3.7791e-05 |   0.0 |  0.00
Modify  | 0.061574   | 0.061574   | 0.061574   |   0.0 |  0.10
Other   |            | 0.005291   |            |       |  0.01

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

Total # of neighbors = 189492
Ave neighs/atom = 94.746
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.828398580598, Press = 0.624377720380554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8405.5374     -8405.5374     -8491.9422     -8491.9422      334.39557      334.39557      23775.471      23775.471     -1432.3836     -1432.3836    
     51000  -8403.9423     -8403.9423     -8491.6635     -8491.6635      339.49005      339.49005      23735.027      23735.027      1625.0512      1625.0512    
Loop time of 58.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.364 hours/ns, 16.975 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    | 58.829     | 58.829     | 58.829     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.03
Output  | 3.7311e-05 | 3.7311e-05 | 3.7311e-05 |   0.0 |  0.00
Modify  | 0.061593   | 0.061593   | 0.061593   |   0.0 |  0.10
Other   |            | 0.005307   |            |       |  0.01

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

Total # of neighbors = 189904
Ave neighs/atom = 94.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.841773992886, Press = 0.30535571513512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8403.9423     -8403.9423     -8491.6635     -8491.6635      339.49005      339.49005      23735.027      23735.027      1625.0512      1625.0512    
     52000  -8402.7894     -8402.7894     -8490.134      -8490.134       338.03295      338.03295      23751.391      23751.391      739.7348       739.7348     
Loop time of 59.0408 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.400 hours/ns, 16.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    | 58.959     | 58.959     | 58.959     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.03
Output  | 3.8713e-05 | 3.8713e-05 | 3.8713e-05 |   0.0 |  0.00
Modify  | 0.061566   | 0.061566   | 0.061566   |   0.0 |  0.10
Other   |            | 0.005288   |            |       |  0.01

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

Total # of neighbors = 190728
Ave neighs/atom = 95.364
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.862476866096, Press = -1.49826471527389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8402.7894     -8402.7894     -8490.134      -8490.134       338.03295      338.03295      23751.391      23751.391      739.7348       739.7348     
     53000  -8402.6117     -8402.6117     -8488.6981     -8488.6981      333.16338      333.16338      23797.229      23797.229     -2282.4558     -2282.4558    
Loop time of 58.9175 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.366 hours/ns, 16.973 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    | 58.836     | 58.836     | 58.836     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014947   | 0.014947   | 0.014947   |   0.0 |  0.03
Output  | 3.8072e-05 | 3.8072e-05 | 3.8072e-05 |   0.0 |  0.00
Modify  | 0.061519   | 0.061519   | 0.061519   |   0.0 |  0.10
Other   |            | 0.00531    |            |       |  0.01

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

Total # of neighbors = 190532
Ave neighs/atom = 95.266
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.958260216878, Press = -0.891952500571116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8402.6117     -8402.6117     -8488.6981     -8488.6981      333.16338      333.16338      23797.229      23797.229     -2282.4558     -2282.4558    
     54000  -8404.1644     -8404.1644     -8491.789      -8491.789       339.11609      339.11609      23743.781      23743.781      1023.9775      1023.9775    
Loop time of 58.7355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.315 hours/ns, 17.025 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    | 58.654     | 58.654     | 58.654     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.03
Output  | 4.4394e-05 | 4.4394e-05 | 4.4394e-05 |   0.0 |  0.00
Modify  | 0.061538   | 0.061538   | 0.061538   |   0.0 |  0.10
Other   |            | 0.005285   |            |       |  0.01

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

Total # of neighbors = 188994
Ave neighs/atom = 94.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.982119744233, Press = 2.77962775573111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8404.1644     -8404.1644     -8491.789      -8491.789       339.11609      339.11609      23743.781      23743.781      1023.9775      1023.9775    
     55000  -8405.2528     -8405.2528     -8490.0254     -8490.0254      328.0785       328.0785       23716.677      23716.677      3175.5192      3175.5192    
Loop time of 58.7544 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.321 hours/ns, 17.020 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    | 58.673     | 58.673     | 58.673     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.03
Output  | 3.0808e-05 | 3.0808e-05 | 3.0808e-05 |   0.0 |  0.00
Modify  | 0.061567   | 0.061567   | 0.061567   |   0.0 |  0.10
Other   |            | 0.00534    |            |       |  0.01

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

Total # of neighbors = 190414
Ave neighs/atom = 95.207
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.036380042586, Press = -1.30497203929962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8405.2528     -8405.2528     -8490.0254     -8490.0254      328.0785       328.0785       23716.677      23716.677      3175.5192      3175.5192    
     56000  -8403.4851     -8403.4851     -8490.2805     -8490.2805      335.90715      335.90715      23782.303      23782.303     -1548.0151     -1548.0151    
Loop time of 59.0373 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.399 hours/ns, 16.938 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    | 58.955     | 58.955     | 58.955     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015007   | 0.015007   | 0.015007   |   0.0 |  0.03
Output  | 3.5477e-05 | 3.5477e-05 | 3.5477e-05 |   0.0 |  0.00
Modify  | 0.061622   | 0.061622   | 0.061622   |   0.0 |  0.10
Other   |            | 0.00536    |            |       |  0.01

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

Total # of neighbors = 191200
Ave neighs/atom = 95.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.021405695157, Press = -0.910394088483229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8403.4851     -8403.4851     -8490.2805     -8490.2805      335.90715      335.90715      23782.303      23782.303     -1548.0151     -1548.0151    
     57000  -8403.3377     -8403.3377     -8489.7992     -8489.7992      334.6152       334.6152       23775.373      23775.373     -903.95893     -903.95893    
Loop time of 58.7809 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.328 hours/ns, 17.012 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    | 58.699     | 58.699     | 58.699     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015      | 0.015      | 0.015      |   0.0 |  0.03
Output  | 3.0337e-05 | 3.0337e-05 | 3.0337e-05 |   0.0 |  0.00
Modify  | 0.061617   | 0.061617   | 0.061617   |   0.0 |  0.10
Other   |            | 0.005293   |            |       |  0.01

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

Total # of neighbors = 189598
Ave neighs/atom = 94.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.022559671023, Press = 0.48249856878389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8403.3377     -8403.3377     -8489.7992     -8489.7992      334.6152       334.6152       23775.373      23775.373     -903.95893     -903.95893    
     58000  -8405.01       -8405.01       -8492.2538     -8492.2538      337.64243      337.64243      23724.86       23724.86       2200.3307      2200.3307    
Loop time of 58.8139 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.337 hours/ns, 17.003 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    | 58.732     | 58.732     | 58.732     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.03
Output  | 2.9515e-05 | 2.9515e-05 | 2.9515e-05 |   0.0 |  0.00
Modify  | 0.061695   | 0.061695   | 0.061695   |   0.0 |  0.10
Other   |            | 0.005339   |            |       |  0.01

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

Total # of neighbors = 189696
Ave neighs/atom = 94.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.993545526148, Press = 0.245534772139183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8405.01       -8405.01       -8492.2538     -8492.2538      337.64243      337.64243      23724.86       23724.86       2200.3307      2200.3307    
     59000  -8404.3422     -8404.3422     -8489.5764     -8489.5764      329.86515      329.86515      23762.498      23762.498     -60.722773     -60.722773    
Loop time of 58.9713 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.465 ns/day, 16.381 hours/ns, 16.957 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    | 58.889     | 58.889     | 58.889     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.03
Output  | 2.8614e-05 | 2.8614e-05 | 2.8614e-05 |   0.0 |  0.00
Modify  | 0.061613   | 0.061613   | 0.061613   |   0.0 |  0.10
Other   |            | 0.0053     |            |       |  0.01

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

Total # of neighbors = 190980
Ave neighs/atom = 95.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.998488015951, Press = -2.26698578359607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8404.3422     -8404.3422     -8489.5764     -8489.5764      329.86515      329.86515      23762.498      23762.498     -60.722773     -60.722773    
     60000  -8408.6912     -8408.6912     -8494.194      -8494.194       330.90476      330.90476      23810.53       23810.53      -4277.5036     -4277.5036    
Loop time of 58.9215 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.367 hours/ns, 16.972 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    | 58.84      | 58.84      | 58.84      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.03
Output  | 2.8464e-05 | 2.8464e-05 | 2.8464e-05 |   0.0 |  0.00
Modify  | 0.061543   | 0.061543   | 0.061543   |   0.0 |  0.10
Other   |            | 0.005286   |            |       |  0.01

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

Total # of neighbors = 190148
Ave neighs/atom = 95.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.956801267902, Press = 0.239589572519427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8408.6912     -8408.6912     -8494.194      -8494.194       330.90476      330.90476      23810.53       23810.53      -4277.5036     -4277.5036    
     61000  -8403.6529     -8403.6529     -8489.1079     -8489.1079      330.7195       330.7195       23752.486      23752.486      719.2498       719.2498     
Loop time of 58.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.324 hours/ns, 17.017 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    | 58.683     | 58.683     | 58.683     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014939   | 0.014939   | 0.014939   |   0.0 |  0.03
Output  | 2.7602e-05 | 2.7602e-05 | 2.7602e-05 |   0.0 |  0.00
Modify  | 0.061644   | 0.061644   | 0.061644   |   0.0 |  0.10
Other   |            | 0.005345   |            |       |  0.01

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

Total # of neighbors = 189236
Ave neighs/atom = 94.618
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.936118913132, Press = 0.61215186413952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8403.6529     -8403.6529     -8489.1079     -8489.1079      330.7195       330.7195       23752.486      23752.486      719.2498       719.2498     
     62000  -8409.9805     -8409.9805     -8491.6903     -8491.6903      316.22535      316.22535      23733.295      23733.295      1491.8905      1491.8905    
Loop time of 58.8508 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.347 hours/ns, 16.992 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    | 58.769     | 58.769     | 58.769     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.03
Output  | 2.7121e-05 | 2.7121e-05 | 2.7121e-05 |   0.0 |  0.00
Modify  | 0.061646   | 0.061646   | 0.061646   |   0.0 |  0.10
Other   |            | 0.005344   |            |       |  0.01

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

Total # of neighbors = 190216
Ave neighs/atom = 95.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.893516365981, Press = -0.542226981962624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8409.9805     -8409.9805     -8491.6903     -8491.6903      316.22535      316.22535      23733.295      23733.295      1491.8905      1491.8905    
     63000  -8401.4232     -8401.4232     -8487.8134     -8487.8134      334.33916      334.33916      23781.383      23781.383     -1118.7911     -1118.7911    
Loop time of 58.8758 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.354 hours/ns, 16.985 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    | 58.794     | 58.794     | 58.794     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014906   | 0.014906   | 0.014906   |   0.0 |  0.03
Output  | 3.0387e-05 | 3.0387e-05 | 3.0387e-05 |   0.0 |  0.00
Modify  | 0.06161    | 0.06161    | 0.06161    |   0.0 |  0.10
Other   |            | 0.005329   |            |       |  0.01

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

Total # of neighbors = 190830
Ave neighs/atom = 95.415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.871397666717, Press = -0.616826917106266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8401.4232     -8401.4232     -8487.8134     -8487.8134      334.33916      334.33916      23781.383      23781.383     -1118.7911     -1118.7911    
     64000  -8405.8603     -8405.8603     -8492.417      -8492.417       334.98337      334.98337      23770.351      23770.351     -1042.5846     -1042.5846    
Loop time of 58.734 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.315 hours/ns, 17.026 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    | 58.652     | 58.652     | 58.652     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 4.5476e-05 | 4.5476e-05 | 4.5476e-05 |   0.0 |  0.00
Modify  | 0.061645   | 0.061645   | 0.061645   |   0.0 |  0.10
Other   |            | 0.005305   |            |       |  0.01

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

Total # of neighbors = 189562
Ave neighs/atom = 94.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.861046539981, Press = 0.544219647251683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8405.8603     -8405.8603     -8492.417      -8492.417       334.98337      334.98337      23770.351      23770.351     -1042.5846     -1042.5846    
     65000  -8404.2101     -8404.2101     -8489.5968     -8489.5968      330.45535      330.45535      23722.671      23722.671      2849.8086      2849.8086    
Loop time of 58.728 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.313 hours/ns, 17.028 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.646     | 58.646     | 58.646     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.03
Output  | 4.5406e-05 | 4.5406e-05 | 4.5406e-05 |   0.0 |  0.00
Modify  | 0.06158    | 0.06158    | 0.06158    |   0.0 |  0.10
Other   |            | 0.005247   |            |       |  0.01

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

Total # of neighbors = 190074
Ave neighs/atom = 95.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.843897244944, Press = 0.0962347196817151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8404.2101     -8404.2101     -8489.5968     -8489.5968      330.45535      330.45535      23722.671      23722.671      2849.8086      2849.8086    
     66000  -8403.1798     -8403.1798     -8488.3213     -8488.3213      329.50638      329.50638      23771.087      23771.087     -371.26295     -371.26295    
Loop time of 59.0258 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.464 ns/day, 16.396 hours/ns, 16.942 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.944     | 58.944     | 58.944     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014877   | 0.014877   | 0.014877   |   0.0 |  0.03
Output  | 4.6307e-05 | 4.6307e-05 | 4.6307e-05 |   0.0 |  0.00
Modify  | 0.06166    | 0.06166    | 0.06166    |   0.0 |  0.10
Other   |            | 0.005309   |            |       |  0.01

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

Total # of neighbors = 190924
Ave neighs/atom = 95.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.808151408819, Press = -1.48407526922021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8403.1798     -8403.1798     -8488.3213     -8488.3213      329.50638      329.50638      23771.087      23771.087     -371.26295     -371.26295    
     67000  -8405.6825     -8405.6825     -8491.2239     -8491.2239      331.05379      331.05379      23783.779      23783.779     -1790.4239     -1790.4239    
Loop time of 58.8179 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.338 hours/ns, 17.002 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    | 58.736     | 58.736     | 58.736     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.03
Output  | 4.4594e-05 | 4.4594e-05 | 4.4594e-05 |   0.0 |  0.00
Modify  | 0.061583   | 0.061583   | 0.061583   |   0.0 |  0.10
Other   |            | 0.005284   |            |       |  0.01

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

Total # of neighbors = 189902
Ave neighs/atom = 94.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816751864147, Press = 0.04600257672216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8405.6825     -8405.6825     -8491.2239     -8491.2239      331.05379      331.05379      23783.779      23783.779     -1790.4239     -1790.4239    
     68000  -8400.6365     -8400.6365     -8487.2156     -8487.2156      335.06982      335.06982      23762.18       23762.18       545.21079      545.21079    
Loop time of 58.8572 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.349 hours/ns, 16.990 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    | 58.775     | 58.775     | 58.775     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 4.1449e-05 | 4.1449e-05 | 4.1449e-05 |   0.0 |  0.00
Modify  | 0.061614   | 0.061614   | 0.061614   |   0.0 |  0.10
Other   |            | 0.005299   |            |       |  0.01

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

Total # of neighbors = 189590
Ave neighs/atom = 94.795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.837989731466, Press = 0.666325216468594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8400.6365     -8400.6365     -8487.2156     -8487.2156      335.06982      335.06982      23762.18       23762.18       545.21079      545.21079    
     69000  -8405.9038     -8405.9038     -8491.9516     -8491.9516      333.01386      333.01386      23732.946      23732.946      1814.35        1814.35      
Loop time of 58.8678 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.352 hours/ns, 16.987 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    | 58.786     | 58.786     | 58.786     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.03
Output  | 4.6097e-05 | 4.6097e-05 | 4.6097e-05 |   0.0 |  0.00
Modify  | 0.06153    | 0.06153    | 0.06153    |   0.0 |  0.10
Other   |            | 0.005287   |            |       |  0.01

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

Total # of neighbors = 190048
Ave neighs/atom = 95.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.852627380376, Press = -0.486659819446793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8405.9038     -8405.9038     -8491.9516     -8491.9516      333.01386      333.01386      23732.946      23732.946      1814.35        1814.35      
     70000  -8401.8586     -8401.8586     -8488.6556     -8488.6556      335.91343      335.91343      23797.521      23797.521     -2108.5907     -2108.5907    
Loop time of 59.0749 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.463 ns/day, 16.410 hours/ns, 16.928 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.993     | 58.993     | 58.993     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015095   | 0.015095   | 0.015095   |   0.0 |  0.03
Output  | 4.26e-05   | 4.26e-05   | 4.26e-05   |   0.0 |  0.00
Modify  | 0.061607   | 0.061607   | 0.061607   |   0.0 |  0.10
Other   |            | 0.005262   |            |       |  0.01

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

Total # of neighbors = 190922
Ave neighs/atom = 95.461
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.82111022408, Press = -1.20120638651708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8401.8586     -8401.8586     -8488.6556     -8488.6556      335.91343      335.91343      23797.521      23797.521     -2108.5907     -2108.5907    
     71000  -8404.9047     -8404.9047     -8490.5329     -8490.5329      331.3898       331.3898       23780.605      23780.605     -1376.4401     -1376.4401    
Loop time of 58.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.339 hours/ns, 17.001 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    | 58.738     | 58.738     | 58.738     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.03
Output  | 3.9775e-05 | 3.9775e-05 | 3.9775e-05 |   0.0 |  0.00
Modify  | 0.06164    | 0.06164    | 0.06164    |   0.0 |  0.10
Other   |            | 0.005285   |            |       |  0.01

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

Total # of neighbors = 189188
Ave neighs/atom = 94.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.832258730351, Press = 0.79067353729361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8404.9047     -8404.9047     -8490.5329     -8490.5329      331.3898       331.3898       23780.605      23780.605     -1376.4401     -1376.4401    
     72000  -8403.6051     -8403.6051     -8489.8019     -8489.8019      333.59057      333.59057      23722.114      23722.114      2992.0323      2992.0323    
Loop time of 58.7715 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.325 hours/ns, 17.015 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    | 58.69      | 58.69      | 58.69      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014937   | 0.014937   | 0.014937   |   0.0 |  0.03
Output  | 4.8822e-05 | 4.8822e-05 | 4.8822e-05 |   0.0 |  0.00
Modify  | 0.061582   | 0.061582   | 0.061582   |   0.0 |  0.10
Other   |            | 0.005304   |            |       |  0.01

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

Total # of neighbors = 189722
Ave neighs/atom = 94.861
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.886671035556, Press = 0.252658596558218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8403.6051     -8403.6051     -8489.8019     -8489.8019      333.59057      333.59057      23722.114      23722.114      2992.0323      2992.0323    
     73000  -8402.4048     -8402.4048     -8489.5171     -8489.5171      337.1338       337.1338       23768.89       23768.89      -386.00141     -386.00141    
Loop time of 59.0217 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.464 ns/day, 16.395 hours/ns, 16.943 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    | 58.94      | 58.94      | 58.94      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014881   | 0.014881   | 0.014881   |   0.0 |  0.03
Output  | 4.6487e-05 | 4.6487e-05 | 4.6487e-05 |   0.0 |  0.00
Modify  | 0.061537   | 0.061537   | 0.061537   |   0.0 |  0.10
Other   |            | 0.005269   |            |       |  0.01

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

Total # of neighbors = 191082
Ave neighs/atom = 95.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.898025364351, Press = -1.77303384131762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8402.4048     -8402.4048     -8489.5171     -8489.5171      337.1338       337.1338       23768.89       23768.89      -386.00141     -386.00141    
     74000  -8402.1392     -8402.1392     -8486.3933     -8486.3933      326.07229      326.07229      23807.057      23807.057     -2590.5656     -2590.5656    
Loop time of 58.7893 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.330 hours/ns, 17.010 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    | 58.708     | 58.708     | 58.708     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 4.5316e-05 | 4.5316e-05 | 4.5316e-05 |   0.0 |  0.00
Modify  | 0.061549   | 0.061549   | 0.061549   |   0.0 |  0.10
Other   |            | 0.005256   |            |       |  0.01

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

Total # of neighbors = 190022
Ave neighs/atom = 95.011
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.938892059925, Press = 0.308311704539947
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8402.1392     -8402.1392     -8486.3933     -8486.3933      326.07229      326.07229      23807.057      23807.057     -2590.5656     -2590.5656    
     75000  -8406.0166     -8406.0166     -8493.5099     -8493.5099      338.60812      338.60812      23748.743      23748.743      319.95376      319.95376    
Loop time of 58.6806 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.472 ns/day, 16.300 hours/ns, 17.041 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.599     | 58.599     | 58.599     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015021   | 0.015021   | 0.015021   |   0.0 |  0.03
Output  | 4.3081e-05 | 4.3081e-05 | 4.3081e-05 |   0.0 |  0.00
Modify  | 0.061551   | 0.061551   | 0.061551   |   0.0 |  0.10
Other   |            | 0.005233   |            |       |  0.01

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

Total # of neighbors = 188956
Ave neighs/atom = 94.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.95096323772, Press = 0.482386867599863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8406.0166     -8406.0166     -8493.5099     -8493.5099      338.60812      338.60812      23748.743      23748.743      319.95376      319.95376    
     76000  -8406.0897     -8406.0897     -8491.4892     -8491.4892      330.50497      330.50497      23742.626      23742.626      1009.6447      1009.6447    
Loop time of 58.9419 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.466 ns/day, 16.373 hours/ns, 16.966 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    | 58.86      | 58.86      | 58.86      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.03
Output  | 8.2786e-05 | 8.2786e-05 | 8.2786e-05 |   0.0 |  0.00
Modify  | 0.061599   | 0.061599   | 0.061599   |   0.0 |  0.10
Other   |            | 0.005267   |            |       |  0.01

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

Total # of neighbors = 190468
Ave neighs/atom = 95.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.97322167485, Press = -0.645113659820571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8406.0897     -8406.0897     -8491.4892     -8491.4892      330.50497      330.50497      23742.626      23742.626      1009.6447      1009.6447    
     77000  -8407.6064     -8407.6064     -8492.8082     -8492.8082      329.7399       329.7399       23776.965      23776.965     -1572.589      -1572.589     
Loop time of 58.8723 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.468 ns/day, 16.353 hours/ns, 16.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    | 58.791     | 58.791     | 58.791     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.03
Output  | 4.3242e-05 | 4.3242e-05 | 4.3242e-05 |   0.0 |  0.00
Modify  | 0.061523   | 0.061523   | 0.061523   |   0.0 |  0.10
Other   |            | 0.005278   |            |       |  0.01

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

Total # of neighbors = 190514
Ave neighs/atom = 95.257
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942704529727, Press = -0.409995288049075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8407.6064     -8407.6064     -8492.8082     -8492.8082      329.7399       329.7399       23776.965      23776.965     -1572.589      -1572.589     
     78000  -8405.9894     -8405.9894     -8491.1135     -8491.1135      329.43895      329.43895      23759.894      23759.894     -28.667235     -28.667235    
Loop time of 58.8965 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.467 ns/day, 16.360 hours/ns, 16.979 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    | 58.815     | 58.815     | 58.815     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.03
Output  | 4.2721e-05 | 4.2721e-05 | 4.2721e-05 |   0.0 |  0.00
Modify  | 0.061571   | 0.061571   | 0.061571   |   0.0 |  0.10
Other   |            | 0.0053     |            |       |  0.01

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

Total # of neighbors = 190044
Ave neighs/atom = 95.022
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.933443089767, Press = 0.937206061022241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -8405.9894     -8405.9894     -8491.1135     -8491.1135      329.43895      329.43895      23759.894      23759.894     -28.667235     -28.667235    
     79000  -8402.2552     -8402.2552     -8489.4247     -8489.4247      337.35497      337.35497      23694.61       23694.61       4991.3695      4991.3695    
Loop time of 58.8345 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.343 hours/ns, 16.997 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    | 58.753     | 58.753     | 58.753     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.03
Output  | 4.283e-05  | 4.283e-05  | 4.283e-05  |   0.0 |  0.00
Modify  | 0.061586   | 0.061586   | 0.061586   |   0.0 |  0.10
Other   |            | 0.005269   |            |       |  0.01

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

Total # of neighbors = 190234
Ave neighs/atom = 95.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.941321823812, Press = -0.211022500661152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -8402.2552     -8402.2552     -8489.4247     -8489.4247      337.35497      337.35497      23694.61       23694.61       4991.3695      4991.3695    
     80000  -8404.8027     -8404.8027     -8490.6598     -8490.6598      332.27599      332.27599      23778.779      23778.779     -1228.4593     -1228.4593    
Loop time of 59.1364 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.461 ns/day, 16.427 hours/ns, 16.910 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    | 59.055     | 59.055     | 59.055     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.03
Output  | 4.4424e-05 | 4.4424e-05 | 4.4424e-05 |   0.0 |  0.00
Modify  | 0.061622   | 0.061622   | 0.061622   |   0.0 |  0.10
Other   |            | 0.00531    |            |       |  0.01

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

Total # of neighbors = 191576
Ave neighs/atom = 95.788
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.932387553836, Press = -1.07486245260065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -8404.8027     -8404.8027     -8490.6598     -8490.6598      332.27599      332.27599      23778.779      23778.779     -1228.4593     -1228.4593    
     81000  -8398.648      -8398.648      -8487.8799     -8487.8799      345.33684      345.33684      23801.078      23801.078     -2248.7301     -2248.7301    
Loop time of 58.8072 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.469 ns/day, 16.335 hours/ns, 17.005 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    | 58.725     | 58.725     | 58.725     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.03
Output  | 3.8563e-05 | 3.8563e-05 | 3.8563e-05 |   0.0 |  0.00
Modify  | 0.061532   | 0.061532   | 0.061532   |   0.0 |  0.10
Other   |            | 0.005264   |            |       |  0.01

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

Total # of neighbors = 189642
Ave neighs/atom = 94.821
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.961782227797, Press = 0.52376525493787
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -8398.648      -8398.648      -8487.8799     -8487.8799      345.33684      345.33684      23801.078      23801.078     -2248.7301     -2248.7301    
     82000  -8406.665      -8406.665      -8492.3877     -8492.3877      331.75554      331.75554      23742.29       23742.29       949.53027      949.53027    
Loop time of 58.6361 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.473 ns/day, 16.288 hours/ns, 17.054 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    | 58.554     | 58.554     | 58.554     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.03
Output  | 3.4545e-05 | 3.4545e-05 | 3.4545e-05 |   0.0 |  0.00
Modify  | 0.061549   | 0.061549   | 0.061549   |   0.0 |  0.10
Other   |            | 0.005289   |            |       |  0.01

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

Total # of neighbors = 189114
Ave neighs/atom = 94.557
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.984136122487, Press = 0.420066433564436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -8406.665      -8406.665      -8492.3877     -8492.3877      331.75554      331.75554      23742.29       23742.29       949.53027      949.53027    
     83000  -8403.6927     -8403.6927     -8489.3714     -8489.3714      331.58536      331.58536      23753.247      23753.247      744.24926      744.24926    
Loop time of 58.7841 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.470 ns/day, 16.329 hours/ns, 17.011 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    | 58.702     | 58.702     | 58.702     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.03
Output  | 3.7551e-05 | 3.7551e-05 | 3.7551e-05 |   0.0 |  0.00
Modify  | 0.061573   | 0.061573   | 0.061573   |   0.0 |  0.10
Other   |            | 0.005282   |            |       |  0.01

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

Total # of neighbors = 190582
Ave neighs/atom = 95.291
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.009349558011, Press = -0.490412575408443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.4
  ghost atom cutoff = 6.4
  binsize = 3.2, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.4
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -8403.6927     -8403.6927     -8489.3714     -8489.3714      331.58536      331.58536      23753.247      23753.247      744.24926      744.24926    
     84000  -8403.6277     -8403.6277     -8488.8145     -8488.8145      329.68174      329.68174      23808.066      23808.066     -3088.7285     -3088.7285    
Loop time of 58.7541 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.471 ns/day, 16.321 hours/ns, 17.020 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    | 58.672     | 58.672     | 58.672     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014906   | 0.014906   | 0.014906   |   0.0 |  0.03
Output  | 4.7139e-05 | 4.7139e-05 | 4.7139e-05 |   0.0 |  0.00
Modify  | 0.061584   | 0.061584   | 0.061584   |   0.0 |  0.10
Other   |            | 0.005284   |            |       |  0.01

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0