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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.303000025451184*${_u_distance}
variable latticeconst_converted equal 3.303000025451184*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30300002545118
Lattice spacing in x,y,z = 3.303 3.303 3.303
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.03 33.03 33.03)
  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 (33.03 33.03 33.03)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_GaoOteroAouadi_2013_AgTaO__MO_112077942578_002
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -16109.42      -16109.42      -16180         -16180          273.15         273.15         36035.1        36035.1        2092.0159      2092.0159    
      1000  -16040.03      -16040.03      -16113.748     -16113.748      285.29598      285.29598      36206.367      36206.367      3389.3446      3389.3446    
Loop time of 151.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.157 hours/ns, 6.589 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 151.27     | 151.27     | 151.27     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093548   | 0.093548   | 0.093548   |   0.0 |  0.06
Output  | 0.00021471 | 0.00021471 | 0.00021471 |   0.0 |  0.00
Modify  | 0.33997    | 0.33997    | 0.33997    |   0.0 |  0.22
Other   |            | 0.05968    |            |       |  0.04

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

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

Performance: 0.580 ns/day, 41.385 hours/ns, 6.712 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.49     | 148.49     | 148.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099456   | 0.099456   | 0.099456   |   0.0 |  0.07
Output  | 0.00021274 | 0.00021274 | 0.00021274 |   0.0 |  0.00
Modify  | 0.33778    | 0.33778    | 0.33778    |   0.0 |  0.23
Other   |            | 0.05922    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4293 ave        4293 max        4293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265226 ave      265226 max      265226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 265226
Ave neighs/atom = 132.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -16038.348     -16038.348     -16109.046     -16109.046      273.6083       273.6083       36294.062      36294.062     -422.87984     -422.87984    
      3000  -16042.909     -16042.909     -16109.464     -16109.464      257.57393      257.57393      36302.019      36302.019     -787.59291     -787.59291    
Loop time of 163.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.530 ns/day, 45.319 hours/ns, 6.129 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    | 162.6      | 162.6      | 162.6      |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10679    | 0.10679    | 0.10679    |   0.0 |  0.07
Output  | 0.00020809 | 0.00020809 | 0.00020809 |   0.0 |  0.00
Modify  | 0.38231    | 0.38231    | 0.38231    |   0.0 |  0.23
Other   |            | 0.06398    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4284 ave        4284 max        4284 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264174 ave      264174 max      264174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264174
Ave neighs/atom = 132.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -16042.909     -16042.909     -16109.464     -16109.464      257.57393      257.57393      36302.019      36302.019     -787.59291     -787.59291    
      4000  -16041.187     -16041.187     -16111.011     -16111.011      270.22361      270.22361      36280.974      36280.974     -33.062924     -33.062924    
Loop time of 147.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.053 hours/ns, 6.766 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.29     | 147.29     | 147.29     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098358   | 0.098358   | 0.098358   |   0.0 |  0.07
Output  | 0.00025503 | 0.00025503 | 0.00025503 |   0.0 |  0.00
Modify  | 0.33921    | 0.33921    | 0.33921    |   0.0 |  0.23
Other   |            | 0.06089    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4267 ave        4267 max        4267 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263708 ave      263708 max      263708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263708
Ave neighs/atom = 131.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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -16041.187     -16041.187     -16111.011     -16111.011      270.22361      270.22361      36280.974      36280.974     -33.062924     -33.062924    
      5000  -16039.708     -16039.708     -16109.9       -16109.9        271.64999      271.64999      36268.833      36268.833      741.76843      741.76843    
Loop time of 148.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.299 hours/ns, 6.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.18     | 148.18     | 148.18     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099246   | 0.099246   | 0.099246   |   0.0 |  0.07
Output  | 0.00016698 | 0.00016698 | 0.00016698 |   0.0 |  0.00
Modify  | 0.34059    | 0.34059    | 0.34059    |   0.0 |  0.23
Other   |            | 0.05863    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4264 ave        4264 max        4264 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264434 ave      264434 max      264434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264434
Ave neighs/atom = 132.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 = 277.923649572052, Press = 26.0886746593185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -16039.708     -16039.708     -16109.9       -16109.9        271.64999      271.64999      36268.833      36268.833      741.76843      741.76843    
      6000  -16041.022     -16041.022     -16111.857     -16111.857      274.13868      274.13868      36324.698      36324.698     -2268.5257     -2268.5257    
Loop time of 172.468 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.908 hours/ns, 5.798 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    | 171.86     | 171.86     | 171.86     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11052    | 0.11052    | 0.11052    |   0.0 |  0.06
Output  | 0.00016991 | 0.00016991 | 0.00016991 |   0.0 |  0.00
Modify  | 0.4304     | 0.4304     | 0.4304     |   0.0 |  0.25
Other   |            | 0.06507    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4272 ave        4272 max        4272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264492 ave      264492 max      264492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264492
Ave neighs/atom = 132.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.245100545493, Press = 3.6060095238742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -16041.022     -16041.022     -16111.857     -16111.857      274.13868      274.13868      36324.698      36324.698     -2268.5257     -2268.5257    
      7000  -16038.523     -16038.523     -16109.397     -16109.397      274.2883       274.2883       36270.806      36270.806      939.35087      939.35087    
Loop time of 168.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.917 hours/ns, 5.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.31     | 168.31     | 168.31     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1093     | 0.1093     | 0.1093     |   0.0 |  0.06
Output  | 0.00016957 | 0.00016957 | 0.00016957 |   0.0 |  0.00
Modify  | 0.41932    | 0.41932    | 0.41932    |   0.0 |  0.25
Other   |            | 0.06534    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4245 ave        4245 max        4245 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263966 ave      263966 max      263966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263966
Ave neighs/atom = 131.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936086741808, Press = -25.6225836905676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -16038.523     -16038.523     -16109.397     -16109.397      274.2883       274.2883       36270.806      36270.806      939.35087      939.35087    
      8000  -16040.852     -16040.852     -16110.795     -16110.795      270.68587      270.68587      36272.21       36272.21       352.85919      352.85919    
Loop time of 149.924 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.645 hours/ns, 6.670 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    | 149.4      | 149.4      | 149.4      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099783   | 0.099783   | 0.099783   |   0.0 |  0.07
Output  | 0.00016755 | 0.00016755 | 0.00016755 |   0.0 |  0.00
Modify  | 0.36424    | 0.36424    | 0.36424    |   0.0 |  0.24
Other   |            | 0.06041    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4273 ave        4273 max        4273 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264398 ave      264398 max      264398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264398
Ave neighs/atom = 132.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.474148637782, Press = -6.74410455466378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -16040.852     -16040.852     -16110.795     -16110.795      270.68587      270.68587      36272.21       36272.21       352.85919      352.85919    
      9000  -16041.341     -16041.341     -16110.863     -16110.863      269.05782      269.05782      36301.62       36301.62      -1066.8939     -1066.8939    
Loop time of 148.226 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.174 hours/ns, 6.746 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    | 147.71     | 147.71     | 147.71     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09811    | 0.09811    | 0.09811    |   0.0 |  0.07
Output  | 0.00016802 | 0.00016802 | 0.00016802 |   0.0 |  0.00
Modify  | 0.36042    | 0.36042    | 0.36042    |   0.0 |  0.24
Other   |            | 0.06023    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4226 ave        4226 max        4226 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264338 ave      264338 max      264338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264338
Ave neighs/atom = 132.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.742663658217, Press = -9.1691202521796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -16041.341     -16041.341     -16110.863     -16110.863      269.05782      269.05782      36301.62       36301.62      -1066.8939     -1066.8939    
     10000  -16040.956     -16040.956     -16112.506     -16112.506      276.90315      276.90315      36263.027      36263.027      556.95478      556.95478    
Loop time of 156.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.553 ns/day, 43.436 hours/ns, 6.395 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    | 155.82     | 155.82     | 155.82     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10324    | 0.10324    | 0.10324    |   0.0 |  0.07
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.38515    | 0.38515    | 0.38515    |   0.0 |  0.25
Other   |            | 0.0618     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4260 ave        4260 max        4260 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264232 ave      264232 max      264232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264232
Ave neighs/atom = 132.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.574319887794, Press = -12.6359832866261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -16040.956     -16040.956     -16112.506     -16112.506      276.90315      276.90315      36263.027      36263.027      556.95478      556.95478    
     11000  -16041.388     -16041.388     -16110.872     -16110.872      268.90942      268.90942      36237.032      36237.032      2291.4829      2291.4829    
Loop time of 148.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.376 hours/ns, 6.714 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.43     | 148.43     | 148.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10002    | 0.10002    | 0.10002    |   0.0 |  0.07
Output  | 0.00017114 | 0.00017114 | 0.00017114 |   0.0 |  0.00
Modify  | 0.3589     | 0.3589     | 0.3589     |   0.0 |  0.24
Other   |            | 0.05852    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264510 ave      264510 max      264510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264510
Ave neighs/atom = 132.255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.880407265216, Press = -0.71322263270133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -16041.388     -16041.388     -16110.872     -16110.872      268.90942      268.90942      36237.032      36237.032      2291.4829      2291.4829    
     12000  -16039.279     -16039.279     -16110.167     -16110.167      274.34396      274.34396      36304.795      36304.795     -1255.5011     -1255.5011    
Loop time of 148.84 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.344 hours/ns, 6.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.32     | 148.32     | 148.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10058    | 0.10058    | 0.10058    |   0.0 |  0.07
Output  | 0.00017139 | 0.00017139 | 0.00017139 |   0.0 |  0.00
Modify  | 0.35917    | 0.35917    | 0.35917    |   0.0 |  0.24
Other   |            | 0.05864    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4304 ave        4304 max        4304 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264732 ave      264732 max      264732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264732
Ave neighs/atom = 132.366
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.670515899026, Press = -3.16311037552784
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -16039.279     -16039.279     -16110.167     -16110.167      274.34396      274.34396      36304.795      36304.795     -1255.5011     -1255.5011    
     13000  -16042.211     -16042.211     -16113.171     -16113.171      274.62259      274.62259      36266.293      36266.293      345.13566      345.13566    
Loop time of 149.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.394 hours/ns, 6.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10012    | 0.10012    | 0.10012    |   0.0 |  0.07
Output  | 0.00016818 | 0.00016818 | 0.00016818 |   0.0 |  0.00
Modify  | 0.3597     | 0.3597     | 0.3597     |   0.0 |  0.24
Other   |            | 0.05902    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4279 ave        4279 max        4279 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264110 ave      264110 max      264110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264110
Ave neighs/atom = 132.055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.308832060614, Press = -3.36067415874472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -16042.211     -16042.211     -16113.171     -16113.171      274.62259      274.62259      36266.293      36266.293      345.13566      345.13566    
     14000  -16042.947     -16042.947     -16112.736     -16112.736      270.08986      270.08986      36262.171      36262.171      650.83309      650.83309    
Loop time of 156.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.551 ns/day, 43.533 hours/ns, 6.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.17     | 156.17     | 156.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10333    | 0.10333    | 0.10333    |   0.0 |  0.07
Output  | 0.00043856 | 0.00043856 | 0.00043856 |   0.0 |  0.00
Modify  | 0.384      | 0.384      | 0.384      |   0.0 |  0.25
Other   |            | 0.0611     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4248 ave        4248 max        4248 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264698 ave      264698 max      264698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264698
Ave neighs/atom = 132.349
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.356304560351, Press = -2.12518196804217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -16042.947     -16042.947     -16112.736     -16112.736      270.08986      270.08986      36262.171      36262.171      650.83309      650.83309    
     15000  -16039.834     -16039.834     -16111.946     -16111.946      279.07937      279.07937      36262.089      36262.089      981.59286      981.59286    
Loop time of 149.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.519 hours/ns, 6.690 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.95     | 148.95     | 148.95     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09946    | 0.09946    | 0.09946    |   0.0 |  0.07
Output  | 0.00017136 | 0.00017136 | 0.00017136 |   0.0 |  0.00
Modify  | 0.36201    | 0.36201    | 0.36201    |   0.0 |  0.24
Other   |            | 0.05961    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4265 ave        4265 max        4265 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264450 ave      264450 max      264450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264450
Ave neighs/atom = 132.225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380231634039, Press = 5.64455617606504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -16039.834     -16039.834     -16111.946     -16111.946      279.07937      279.07937      36262.089      36262.089      981.59286      981.59286    
     16000  -16042.422     -16042.422     -16111.936     -16111.936      269.02602      269.02602      36287.279      36287.279     -499.81334     -499.81334    
Loop time of 150.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.574 ns/day, 41.842 hours/ns, 6.639 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.11     | 150.11     | 150.11     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10057    | 0.10057    | 0.10057    |   0.0 |  0.07
Output  | 0.00017194 | 0.00017194 | 0.00017194 |   0.0 |  0.00
Modify  | 0.36625    | 0.36625    | 0.36625    |   0.0 |  0.24
Other   |            | 0.0589     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4263 ave        4263 max        4263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264444 ave      264444 max      264444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264444
Ave neighs/atom = 132.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.316449242923, Press = -1.62227540835634
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -16042.422     -16042.422     -16111.936     -16111.936      269.02602      269.02602      36287.279      36287.279     -499.81334     -499.81334    
     17000  -16038.802     -16038.802     -16109.384     -16109.384      273.15864      273.15864      36300.069      36300.069     -702.5488      -702.5488     
Loop time of 148.526 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.257 hours/ns, 6.733 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.01     | 148.01     | 148.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099794   | 0.099794   | 0.099794   |   0.0 |  0.07
Output  | 0.00017045 | 0.00017045 | 0.00017045 |   0.0 |  0.00
Modify  | 0.35809    | 0.35809    | 0.35809    |   0.0 |  0.24
Other   |            | 0.05837    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4274 ave        4274 max        4274 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264290 ave      264290 max      264290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264290
Ave neighs/atom = 132.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.425246798748, Press = -1.58221544610283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -16038.802     -16038.802     -16109.384     -16109.384      273.15864      273.15864      36300.069      36300.069     -702.5488      -702.5488     
     18000  -16037.11      -16037.11      -16109.788     -16109.788      281.27304      281.27304      36266.947      36266.947      1015.2924      1015.2924    
Loop time of 148.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.184 hours/ns, 6.745 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.74     | 147.74     | 147.74     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10068    | 0.10068    | 0.10068    |   0.0 |  0.07
Output  | 0.00017152 | 0.00017152 | 0.00017152 |   0.0 |  0.00
Modify  | 0.35974    | 0.35974    | 0.35974    |   0.0 |  0.24
Other   |            | 0.05798    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4282 ave        4282 max        4282 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263848 ave      263848 max      263848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263848
Ave neighs/atom = 131.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.380765130499, Press = 0.240600404412374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -16037.11      -16037.11      -16109.788     -16109.788      281.27304      281.27304      36266.947      36266.947      1015.2924      1015.2924    
     19000  -16041.475     -16041.475     -16113.22      -16113.22       277.6602       277.6602       36299.698      36299.698     -1363.7765     -1363.7765    
Loop time of 148.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.293 hours/ns, 6.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.14     | 148.14     | 148.14     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099593   | 0.099593   | 0.099593   |   0.0 |  0.07
Output  | 0.00020755 | 0.00020755 | 0.00020755 |   0.0 |  0.00
Modify  | 0.35809    | 0.35809    | 0.35809    |   0.0 |  0.24
Other   |            | 0.05843    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4266 ave        4266 max        4266 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264606 ave      264606 max      264606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264606
Ave neighs/atom = 132.303
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.472023132129, Press = -2.02609498317697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -16041.475     -16041.475     -16113.22      -16113.22       277.6602       277.6602       36299.698      36299.698     -1363.7765     -1363.7765    
     20000  -16042.935     -16042.935     -16113.502     -16113.502      273.09891      273.09891      36230.563      36230.563      2302.6028      2302.6028    
Loop time of 148.803 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.334 hours/ns, 6.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.29     | 148.29     | 148.29     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099205   | 0.099205   | 0.099205   |   0.0 |  0.07
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.35872    | 0.35872    | 0.35872    |   0.0 |  0.24
Other   |            | 0.05835    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4281 ave        4281 max        4281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264190 ave      264190 max      264190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264190
Ave neighs/atom = 132.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.499012529244, Press = -1.30631741969544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -16042.935     -16042.935     -16113.502     -16113.502      273.09891      273.09891      36230.563      36230.563      2302.6028      2302.6028    
     21000  -16037.711     -16037.711     -16109.354     -16109.354      277.26588      277.26588      36297.514      36297.514     -599.06359     -599.06359    
Loop time of 149.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.487 hours/ns, 6.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.84     | 148.84     | 148.84     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1005     | 0.1005     | 0.1005     |   0.0 |  0.07
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.35787    | 0.35787    | 0.35787    |   0.0 |  0.24
Other   |            | 0.05886    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4287 ave        4287 max        4287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264998 ave      264998 max      264998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264998
Ave neighs/atom = 132.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.579721037957, Press = 0.64696185233114
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -16037.711     -16037.711     -16109.354     -16109.354      277.26588      277.26588      36297.514      36297.514     -599.06359     -599.06359    
     22000  -16040.699     -16040.699     -16112.001     -16112.001      275.94881      275.94881      36265.584      36265.584      727.62491      727.62491    
Loop time of 148.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.261 hours/ns, 6.732 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.02     | 148.02     | 148.02     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099311   | 0.099311   | 0.099311   |   0.0 |  0.07
Output  | 0.00021117 | 0.00021117 | 0.00021117 |   0.0 |  0.00
Modify  | 0.35784    | 0.35784    | 0.35784    |   0.0 |  0.24
Other   |            | 0.05865    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4288 ave        4288 max        4288 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263930 ave      263930 max      263930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263930
Ave neighs/atom = 131.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.574915250084, Press = -0.391988011478194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -16040.699     -16040.699     -16112.001     -16112.001      275.94881      275.94881      36265.584      36265.584      727.62491      727.62491    
     23000  -16039.333     -16039.333     -16109.978     -16109.978      273.4031       273.4031       36326.611      36326.611     -2267.5968     -2267.5968    
Loop time of 149.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.485 hours/ns, 6.696 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.83     | 148.83     | 148.83     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098587   | 0.098587   | 0.098587   |   0.0 |  0.07
Output  | 0.00017039 | 0.00017039 | 0.00017039 |   0.0 |  0.00
Modify  | 0.35888    | 0.35888    | 0.35888    |   0.0 |  0.24
Other   |            | 0.05842    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4251 ave        4251 max        4251 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264416 ave      264416 max      264416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264416
Ave neighs/atom = 132.208
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.525727144943, Press = -0.639672298774033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -16039.333     -16039.333     -16109.978     -16109.978      273.4031       273.4031       36326.611      36326.611     -2267.5968     -2267.5968    
     24000  -16041.63      -16041.63      -16111.453     -16111.453      270.22345      270.22345      36314.482      36314.482     -1731.1125     -1731.1125    
Loop time of 148.699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.305 hours/ns, 6.725 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.18     | 148.18     | 148.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098259   | 0.098259   | 0.098259   |   0.0 |  0.07
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.35707    | 0.35707    | 0.35707    |   0.0 |  0.24
Other   |            | 0.05898    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4243 ave        4243 max        4243 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263988 ave      263988 max      263988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263988
Ave neighs/atom = 131.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.500122675352, Press = -3.12259412239147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -16041.63      -16041.63      -16111.453     -16111.453      270.22345      270.22345      36314.482      36314.482     -1731.1125     -1731.1125    
     25000  -16035.651     -16035.651     -16108.079     -16108.079      280.30274      280.30274      36256.625      36256.625      1749.0474      1749.0474    
Loop time of 148.521 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.256 hours/ns, 6.733 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148        | 148        | 148        |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09814    | 0.09814    | 0.09814    |   0.0 |  0.07
Output  | 0.00016969 | 0.00016969 | 0.00016969 |   0.0 |  0.00
Modify  | 0.35907    | 0.35907    | 0.35907    |   0.0 |  0.24
Other   |            | 0.05915    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4276 ave        4276 max        4276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264290 ave      264290 max      264290 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264290
Ave neighs/atom = 132.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.58578340501, Press = -0.776809691829895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -16035.651     -16035.651     -16108.079     -16108.079      280.30274      280.30274      36256.625      36256.625      1749.0474      1749.0474    
     26000  -16042.168     -16042.168     -16112.474     -16112.474      272.08988      272.08988      36316.256      36316.256     -2076.0855     -2076.0855    
Loop time of 152.701 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.566 ns/day, 42.417 hours/ns, 6.549 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 152.17     | 152.17     | 152.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10151    | 0.10151    | 0.10151    |   0.0 |  0.07
Output  | 0.00021641 | 0.00021641 | 0.00021641 |   0.0 |  0.00
Modify  | 0.37049    | 0.37049    | 0.37049    |   0.0 |  0.24
Other   |            | 0.05945    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4263 ave        4263 max        4263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264456 ave      264456 max      264456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264456
Ave neighs/atom = 132.228
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.644616984362, Press = -2.14593557518851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -16042.168     -16042.168     -16112.474     -16112.474      272.08988      272.08988      36316.256      36316.256     -2076.0855     -2076.0855    
     27000  -16041.689     -16041.689     -16111.305     -16111.305      269.42019      269.42019      36261.581      36261.581      1001.7128      1001.7128    
Loop time of 174.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.472 hours/ns, 5.731 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.88     | 173.88     | 173.88     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11148    | 0.11148    | 0.11148    |   0.0 |  0.06
Output  | 0.00016798 | 0.00016798 | 0.00016798 |   0.0 |  0.00
Modify  | 0.44328    | 0.44328    | 0.44328    |   0.0 |  0.25
Other   |            | 0.06643    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4241 ave        4241 max        4241 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264198 ave      264198 max      264198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264198
Ave neighs/atom = 132.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.702266530503, Press = -2.01235738823999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -16041.689     -16041.689     -16111.305     -16111.305      269.42019      269.42019      36261.581      36261.581      1001.7128      1001.7128    
     28000  -16040.818     -16040.818     -16110         -16110          267.74347      267.74347      36317.531      36317.531     -1729.5889     -1729.5889    
Loop time of 174.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.589 hours/ns, 5.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.3      | 174.3      | 174.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11328    | 0.11328    | 0.11328    |   0.0 |  0.06
Output  | 0.00023188 | 0.00023188 | 0.00023188 |   0.0 |  0.00
Modify  | 0.44499    | 0.44499    | 0.44499    |   0.0 |  0.25
Other   |            | 0.06619    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4304 ave        4304 max        4304 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264602 ave      264602 max      264602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264602
Ave neighs/atom = 132.301
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.678013529841, Press = 0.152136898779549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -16040.818     -16040.818     -16110         -16110          267.74347      267.74347      36317.531      36317.531     -1729.5889     -1729.5889    
     29000  -16042.02      -16042.02      -16112.196     -16112.196      271.59007      271.59007      36269.925      36269.925      445.16375      445.16375    
Loop time of 174.529 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.480 hours/ns, 5.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.91     | 173.91     | 173.91     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11207    | 0.11207    | 0.11207    |   0.0 |  0.06
Output  | 0.00017168 | 0.00017168 | 0.00017168 |   0.0 |  0.00
Modify  | 0.43988    | 0.43988    | 0.43988    |   0.0 |  0.25
Other   |            | 0.06619    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4250 ave        4250 max        4250 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264010 ave      264010 max      264010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264010
Ave neighs/atom = 132.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.541809612864, Press = -1.85106501533354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -16042.02      -16042.02      -16112.196     -16112.196      271.59007      271.59007      36269.925      36269.925      445.16375      445.16375    
     30000  -16042.847     -16042.847     -16110.638     -16110.638      262.3587       262.3587       36252.325      36252.325      1433.5501      1433.5501    
Loop time of 175.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.765 hours/ns, 5.696 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    | 174.93     | 174.93     | 174.93     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11392    | 0.11392    | 0.11392    |   0.0 |  0.06
Output  | 0.00017342 | 0.00017342 | 0.00017342 |   0.0 |  0.00
Modify  | 0.44576    | 0.44576    | 0.44576    |   0.0 |  0.25
Other   |            | 0.06685    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264566 ave      264566 max      264566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264566
Ave neighs/atom = 132.283
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.592262656007, Press = 1.77536383375104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -16042.847     -16042.847     -16110.638     -16110.638      262.3587       262.3587       36252.325      36252.325      1433.5501      1433.5501    
     31000  -16041.543     -16041.543     -16113.244     -16113.244      277.48916      277.48916      36285.452      36285.452     -561.18367     -561.18367    
Loop time of 175.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.705 hours/ns, 5.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.71     | 174.71     | 174.71     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11479    | 0.11479    | 0.11479    |   0.0 |  0.07
Output  | 0.00021468 | 0.00021468 | 0.00021468 |   0.0 |  0.00
Modify  | 0.4412     | 0.4412     | 0.4412     |   0.0 |  0.25
Other   |            | 0.0676     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4285 ave        4285 max        4285 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264630 ave      264630 max      264630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264630
Ave neighs/atom = 132.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.56862044025, Press = -0.739308596086669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -16041.543     -16041.543     -16113.244     -16113.244      277.48916      277.48916      36285.452      36285.452     -561.18367     -561.18367    
     32000  -16036.441     -16036.441     -16110.14      -16110.14       285.22022      285.22022      36255.869      36255.869      1488.8397      1488.8397    
Loop time of 175.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.637 hours/ns, 5.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.46     | 174.46     | 174.46     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11435    | 0.11435    | 0.11435    |   0.0 |  0.07
Output  | 0.00021401 | 0.00021401 | 0.00021401 |   0.0 |  0.00
Modify  | 0.44753    | 0.44753    | 0.44753    |   0.0 |  0.26
Other   |            | 0.06722    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4276 ave        4276 max        4276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264572 ave      264572 max      264572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264572
Ave neighs/atom = 132.286
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.602328706756, Press = 0.320932634019915
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -16036.441     -16036.441     -16110.14      -16110.14       285.22022      285.22022      36255.869      36255.869      1488.8397      1488.8397    
     33000  -16041.708     -16041.708     -16112.449     -16112.449      273.77729      273.77729      36250.596      36250.596      1310.1945      1310.1945    
Loop time of 156.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.553 ns/day, 43.389 hours/ns, 6.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.65     | 155.65     | 155.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10434    | 0.10434    | 0.10434    |   0.0 |  0.07
Output  | 0.00021384 | 0.00021384 | 0.00021384 |   0.0 |  0.00
Modify  | 0.38374    | 0.38374    | 0.38374    |   0.0 |  0.25
Other   |            | 0.06137    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4309 ave        4309 max        4309 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264446 ave      264446 max      264446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264446
Ave neighs/atom = 132.223
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.626598430381, Press = -2.21652381235304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -16041.708     -16041.708     -16112.449     -16112.449      273.77729      273.77729      36250.596      36250.596      1310.1945      1310.1945    
     34000  -16041.93      -16041.93      -16111.941     -16111.941      270.95023      270.95023      36202.374      36202.374      3892.8003      3892.8003    
Loop time of 169.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.112 hours/ns, 5.896 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169        | 169        | 169        |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10979    | 0.10979    | 0.10979    |   0.0 |  0.06
Output  | 0.00016923 | 0.00016923 | 0.00016923 |   0.0 |  0.00
Modify  | 0.42607    | 0.42607    | 0.42607    |   0.0 |  0.25
Other   |            | 0.06503    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4271 ave        4271 max        4271 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264686 ave      264686 max      264686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264686
Ave neighs/atom = 132.343
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.666988664788, Press = 0.368016827475988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -16041.93      -16041.93      -16111.941     -16111.941      270.95023      270.95023      36202.374      36202.374      3892.8003      3892.8003    
     35000  -16042.324     -16042.324     -16112.184     -16112.184      270.36515      270.36515      36290.346      36290.346     -764.83282     -764.83282    
Loop time of 175.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.661 hours/ns, 5.708 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.56     | 174.56     | 174.56     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11294    | 0.11294    | 0.11294    |   0.0 |  0.06
Output  | 0.00017069 | 0.00017069 | 0.00017069 |   0.0 |  0.00
Modify  | 0.44406    | 0.44406    | 0.44406    |   0.0 |  0.25
Other   |            | 0.06618    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4275 ave        4275 max        4275 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265050 ave      265050 max      265050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 265050
Ave neighs/atom = 132.525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.687168700365, Press = -0.488442074945942
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -16042.324     -16042.324     -16112.184     -16112.184      270.36515      270.36515      36290.346      36290.346     -764.83282     -764.83282    
     36000  -16039.693     -16039.693     -16109.18      -16109.18       268.92209      268.92209      36267.214      36267.214      957.16547      957.16547    
Loop time of 175.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.672 hours/ns, 5.707 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.6      | 174.6      | 174.6      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11261    | 0.11261    | 0.11261    |   0.0 |  0.06
Output  | 0.00017092 | 0.00017092 | 0.00017092 |   0.0 |  0.00
Modify  | 0.44495    | 0.44495    | 0.44495    |   0.0 |  0.25
Other   |            | 0.06598    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4258 ave        4258 max        4258 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264340 ave      264340 max      264340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264340
Ave neighs/atom = 132.17
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.639098336603, Press = -0.992087356338385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -16039.693     -16039.693     -16109.18      -16109.18       268.92209      268.92209      36267.214      36267.214      957.16547      957.16547    
     37000  -16040.771     -16040.771     -16112.639     -16112.639      278.13386      278.13386      36261.965      36261.965      833.00461      833.00461    
Loop time of 175.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.643 hours/ns, 5.711 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.49     | 174.49     | 174.49     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11299    | 0.11299    | 0.11299    |   0.0 |  0.06
Output  | 0.00020905 | 0.00020905 | 0.00020905 |   0.0 |  0.00
Modify  | 0.44368    | 0.44368    | 0.44368    |   0.0 |  0.25
Other   |            | 0.06674    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4274 ave        4274 max        4274 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264202 ave      264202 max      264202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264202
Ave neighs/atom = 132.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.674836067129, Press = 0.386695096217029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -16040.771     -16040.771     -16112.639     -16112.639      278.13386      278.13386      36261.965      36261.965      833.00461      833.00461    
     38000  -16040.72      -16040.72      -16109.832     -16109.832      267.47207      267.47207      36301.211      36301.211     -652.51685     -652.51685    
Loop time of 174.898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.494 ns/day, 48.583 hours/ns, 5.718 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.28     | 174.28     | 174.28     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11308    | 0.11308    | 0.11308    |   0.0 |  0.06
Output  | 0.00021481 | 0.00021481 | 0.00021481 |   0.0 |  0.00
Modify  | 0.44251    | 0.44251    | 0.44251    |   0.0 |  0.25
Other   |            | 0.06654    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4286 ave        4286 max        4286 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264694 ave      264694 max      264694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264694
Ave neighs/atom = 132.347
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.581463399981, Press = -1.72183931610357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -16040.72      -16040.72      -16109.832     -16109.832      267.47207      267.47207      36301.211      36301.211     -652.51685     -652.51685    
     39000  -16041.822     -16041.822     -16112.896     -16112.896      275.06493      275.06493      36286.968      36286.968     -551.27594     -551.27594    
Loop time of 174.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.371 hours/ns, 5.743 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.51     | 173.51     | 173.51     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11431    | 0.11431    | 0.11431    |   0.0 |  0.07
Output  | 0.00016917 | 0.00016917 | 0.00016917 |   0.0 |  0.00
Modify  | 0.44432    | 0.44432    | 0.44432    |   0.0 |  0.26
Other   |            | 0.06692    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4284 ave        4284 max        4284 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264042 ave      264042 max      264042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264042
Ave neighs/atom = 132.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.570892765051, Press = 1.1352473847981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -16041.822     -16041.822     -16112.896     -16112.896      275.06493      275.06493      36286.968      36286.968     -551.27594     -551.27594    
     40000  -16037.397     -16037.397     -16111.234     -16111.234      285.75553      285.75553      36289.379      36289.379     -353.90722     -353.90722    
Loop time of 170.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.260 hours/ns, 5.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.53     | 169.53     | 169.53     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11111    | 0.11111    | 0.11111    |   0.0 |  0.07
Output  | 0.00017118 | 0.00017118 | 0.00017118 |   0.0 |  0.00
Modify  | 0.43084    | 0.43084    | 0.43084    |   0.0 |  0.25
Other   |            | 0.06601    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4293 ave        4293 max        4293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264582 ave      264582 max      264582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264582
Ave neighs/atom = 132.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 = 273.603288184143, Press = -1.17965946732911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -16037.397     -16037.397     -16111.234     -16111.234      285.75553      285.75553      36289.379      36289.379     -353.90722     -353.90722    
     41000  -16041.976     -16041.976     -16109.829     -16109.829      262.59953      262.59953      36257.369      36257.369      1308.1865      1308.1865    
Loop time of 149.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.411 hours/ns, 6.708 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.56     | 148.56     | 148.56     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098757   | 0.098757   | 0.098757   |   0.0 |  0.07
Output  | 0.00017121 | 0.00017121 | 0.00017121 |   0.0 |  0.00
Modify  | 0.36128    | 0.36128    | 0.36128    |   0.0 |  0.24
Other   |            | 0.05963    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4234 ave        4234 max        4234 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264490 ave      264490 max      264490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264490
Ave neighs/atom = 132.245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.587539748264, Press = 0.100264233367219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -16041.976     -16041.976     -16109.829     -16109.829      262.59953      262.59953      36257.369      36257.369      1308.1865      1308.1865    
     42000  -16036.252     -16036.252     -16109.024     -16109.024      281.63374      281.63374      36303.152      36303.152     -759.74008     -759.74008    
Loop time of 149.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.525 hours/ns, 6.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.97     | 148.97     | 148.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099178   | 0.099178   | 0.099178   |   0.0 |  0.07
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.36069    | 0.36069    | 0.36069    |   0.0 |  0.24
Other   |            | 0.05896    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4252 ave        4252 max        4252 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264502 ave      264502 max      264502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264502
Ave neighs/atom = 132.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.637172521324, Press = 0.014116916600817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -16036.252     -16036.252     -16109.024     -16109.024      281.63374      281.63374      36303.152      36303.152     -759.74008     -759.74008    
     43000  -16042.046     -16042.046     -16110.417     -16110.417      264.60045      264.60045      36301.479      36301.479     -977.33702     -977.33702    
Loop time of 149.59 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.553 hours/ns, 6.685 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.07     | 149.07     | 149.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10026    | 0.10026    | 0.10026    |   0.0 |  0.07
Output  | 0.00017316 | 0.00017316 | 0.00017316 |   0.0 |  0.00
Modify  | 0.36105    | 0.36105    | 0.36105    |   0.0 |  0.24
Other   |            | 0.05917    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4308 ave        4308 max        4308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263820 ave      263820 max      263820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263820
Ave neighs/atom = 131.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.664588604994, Press = 0.092316460633631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -16042.046     -16042.046     -16110.417     -16110.417      264.60045      264.60045      36301.479      36301.479     -977.33702     -977.33702    
     44000  -16038.711     -16038.711     -16111.802     -16111.802      282.87015      282.87015      36302.864      36302.864     -1186.4879     -1186.4879    
Loop time of 167.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.517 ns/day, 46.398 hours/ns, 5.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    | 166.44     | 166.44     | 166.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1086     | 0.1086     | 0.1086     |   0.0 |  0.07
Output  | 0.00016969 | 0.00016969 | 0.00016969 |   0.0 |  0.00
Modify  | 0.41721    | 0.41721    | 0.41721    |   0.0 |  0.25
Other   |            | 0.06473    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4277 ave        4277 max        4277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264098 ave      264098 max      264098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264098
Ave neighs/atom = 132.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.615029434264, Press = -0.0477241668282576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -16038.711     -16038.711     -16111.802     -16111.802      282.87015      282.87015      36302.864      36302.864     -1186.4879     -1186.4879    
     45000  -16041.096     -16041.096     -16110.118     -16110.118      267.12601      267.12601      36266.065      36266.065      858.97573      858.97573    
Loop time of 175.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.865 hours/ns, 5.685 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    | 175.28     | 175.28     | 175.28     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11323    | 0.11323    | 0.11323    |   0.0 |  0.06
Output  | 0.00047708 | 0.00047708 | 0.00047708 |   0.0 |  0.00
Modify  | 0.44806    | 0.44806    | 0.44806    |   0.0 |  0.25
Other   |            | 0.06752    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4276 ave        4276 max        4276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264096 ave      264096 max      264096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264096
Ave neighs/atom = 132.048
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.546683988249, Press = -1.68806961552106
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -16041.096     -16041.096     -16110.118     -16110.118      267.12601      267.12601      36266.065      36266.065      858.97573      858.97573    
     46000  -16041.727     -16041.727     -16112.133     -16112.133      272.47974      272.47974      36257.053      36257.053      944.7378       944.7378     
Loop time of 176.023 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.895 hours/ns, 5.681 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    | 175.39     | 175.39     | 175.39     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11307    | 0.11307    | 0.11307    |   0.0 |  0.06
Output  | 0.00021107 | 0.00021107 | 0.00021107 |   0.0 |  0.00
Modify  | 0.44782    | 0.44782    | 0.44782    |   0.0 |  0.25
Other   |            | 0.06665    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4250 ave        4250 max        4250 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264406 ave      264406 max      264406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264406
Ave neighs/atom = 132.203
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.577297488521, Press = 0.660503760260791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -16041.727     -16041.727     -16112.133     -16112.133      272.47974      272.47974      36257.053      36257.053      944.7378       944.7378     
     47000  -16038.862     -16038.862     -16109.268     -16109.268      272.47815      272.47815      36278.15       36278.15       445.67913      445.67913    
Loop time of 157.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.632 hours/ns, 6.366 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    | 156.52     | 156.52     | 156.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10345    | 0.10345    | 0.10345    |   0.0 |  0.07
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.38737    | 0.38737    | 0.38737    |   0.0 |  0.25
Other   |            | 0.06244    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4276 ave        4276 max        4276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264574 ave      264574 max      264574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264574
Ave neighs/atom = 132.287
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.5914659303, Press = -0.563608616807524
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -16038.862     -16038.862     -16109.268     -16109.268      272.47815      272.47815      36278.15       36278.15       445.67913      445.67913    
     48000  -16041.64      -16041.64      -16111.736     -16111.736      271.27719      271.27719      36251.156      36251.156      1340.78        1340.78      
Loop time of 148.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.352 hours/ns, 6.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.35     | 148.35     | 148.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099199   | 0.099199   | 0.099199   |   0.0 |  0.07
Output  | 0.0002094  | 0.0002094  | 0.0002094  |   0.0 |  0.00
Modify  | 0.36008    | 0.36008    | 0.36008    |   0.0 |  0.24
Other   |            | 0.06001    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4265 ave        4265 max        4265 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264248 ave      264248 max      264248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264248
Ave neighs/atom = 132.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.641033937812, Press = 0.665418257773313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -16041.64      -16041.64      -16111.736     -16111.736      271.27719      271.27719      36251.156      36251.156      1340.78        1340.78      
     49000  -16040.259     -16040.259     -16110.904     -16110.904      273.40161      273.40161      36315.597      36315.597     -1723.576      -1723.576     
Loop time of 149.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.515 hours/ns, 6.691 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.93     | 148.93     | 148.93     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10024    | 0.10024    | 0.10024    |   0.0 |  0.07
Output  | 0.00017124 | 0.00017124 | 0.00017124 |   0.0 |  0.00
Modify  | 0.36086    | 0.36086    | 0.36086    |   0.0 |  0.24
Other   |            | 0.05975    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4254 ave        4254 max        4254 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264646 ave      264646 max      264646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264646
Ave neighs/atom = 132.323
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.64648575134, Press = -0.234229709202756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -16040.259     -16040.259     -16110.904     -16110.904      273.40161      273.40161      36315.597      36315.597     -1723.576      -1723.576     
     50000  -16041.719     -16041.719     -16110.564     -16110.564      266.43975      266.43975      36316.255      36316.255     -1732.1333     -1732.1333    
Loop time of 148.572 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.270 hours/ns, 6.731 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    | 148.05     | 148.05     | 148.05     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099987   | 0.099987   | 0.099987   |   0.0 |  0.07
Output  | 0.00017015 | 0.00017015 | 0.00017015 |   0.0 |  0.00
Modify  | 0.36137    | 0.36137    | 0.36137    |   0.0 |  0.24
Other   |            | 0.06035    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4271 ave        4271 max        4271 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263892 ave      263892 max      263892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263892
Ave neighs/atom = 131.946
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.53961695462, Press = -0.419617296711173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -16041.719     -16041.719     -16110.564     -16110.564      266.43975      266.43975      36316.255      36316.255     -1732.1333     -1732.1333    
     51000  -16041.019     -16041.019     -16110.631     -16110.631      269.40804      269.40804      36255.507      36255.507      1303.6343      1303.6343    
Loop time of 148.492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.248 hours/ns, 6.734 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    | 147.97     | 147.97     | 147.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099609   | 0.099609   | 0.099609   |   0.0 |  0.07
Output  | 0.00020768 | 0.00020768 | 0.00020768 |   0.0 |  0.00
Modify  | 0.363      | 0.363      | 0.363      |   0.0 |  0.24
Other   |            | 0.06024    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4264 ave        4264 max        4264 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263998 ave      263998 max      263998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263998
Ave neighs/atom = 131.999
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.530524391527, Press = -0.518435825252699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -16041.019     -16041.019     -16110.631     -16110.631      269.40804      269.40804      36255.507      36255.507      1303.6343      1303.6343    
     52000  -16040.623     -16040.623     -16111.899     -16111.899      275.84623      275.84623      36259.719      36259.719      1020.1328      1020.1328    
Loop time of 160.421 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.539 ns/day, 44.562 hours/ns, 6.234 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    | 159.85     | 159.85     | 159.85     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10679    | 0.10679    | 0.10679    |   0.0 |  0.07
Output  | 0.00021797 | 0.00021797 | 0.00021797 |   0.0 |  0.00
Modify  | 0.39996    | 0.39996    | 0.39996    |   0.0 |  0.25
Other   |            | 0.06332    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4287 ave        4287 max        4287 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264516 ave      264516 max      264516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264516
Ave neighs/atom = 132.258
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46860612237, Press = 0.0853072614142592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -16040.623     -16040.623     -16111.899     -16111.899      275.84623      275.84623      36259.719      36259.719      1020.1328      1020.1328    
     53000  -16042.024     -16042.024     -16113.007     -16113.007      274.70974      274.70974      36242.418      36242.418      1770.7633      1770.7633    
Loop time of 168.738 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.872 hours/ns, 5.926 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.14     | 168.14     | 168.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11039    | 0.11039    | 0.11039    |   0.0 |  0.07
Output  | 0.00017075 | 0.00017075 | 0.00017075 |   0.0 |  0.00
Modify  | 0.42446    | 0.42446    | 0.42446    |   0.0 |  0.25
Other   |            | 0.0653     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4270 ave        4270 max        4270 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264598 ave      264598 max      264598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264598
Ave neighs/atom = 132.299
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46348301698, Press = -0.571277684648407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -16042.024     -16042.024     -16113.007     -16113.007      274.70974      274.70974      36242.418      36242.418      1770.7633      1770.7633    
     54000  -16040.26      -16040.26      -16111.262     -16111.262      274.78557      274.78557      36276.563      36276.563      320.37966      320.37966    
Loop time of 149.268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.463 hours/ns, 6.699 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.74     | 148.74     | 148.74     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.07
Output  | 0.00017059 | 0.00017059 | 0.00017059 |   0.0 |  0.00
Modify  | 0.36242    | 0.36242    | 0.36242    |   0.0 |  0.24
Other   |            | 0.0595     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4288 ave        4288 max        4288 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264924 ave      264924 max      264924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264924
Ave neighs/atom = 132.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 = 273.481169434707, Press = 0.297403745224545
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -16040.26      -16040.26      -16111.262     -16111.262      274.78557      274.78557      36276.563      36276.563      320.37966      320.37966    
     55000  -16038.805     -16038.805     -16111.007     -16111.007      279.42924      279.42924      36304.816      36304.816     -1381.1006     -1381.1006    
Loop time of 148.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.315 hours/ns, 6.723 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.21     | 148.21     | 148.21     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10079    | 0.10079    | 0.10079    |   0.0 |  0.07
Output  | 0.00017136 | 0.00017136 | 0.00017136 |   0.0 |  0.00
Modify  | 0.36072    | 0.36072    | 0.36072    |   0.0 |  0.24
Other   |            | 0.05959    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4276 ave        4276 max        4276 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264418 ave      264418 max      264418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264418
Ave neighs/atom = 132.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466030227724, Press = -0.43014172152234
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -16038.805     -16038.805     -16111.007     -16111.007      279.42924      279.42924      36304.816      36304.816     -1381.1006     -1381.1006    
     56000  -16041.739     -16041.739     -16111.896     -16111.896      271.51695      271.51695      36256.888      36256.888      906.61769      906.61769    
Loop time of 148.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.301 hours/ns, 6.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.16     | 148.16     | 148.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099029   | 0.099029   | 0.099029   |   0.0 |  0.07
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.36042    | 0.36042    | 0.36042    |   0.0 |  0.24
Other   |            | 0.05952    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4226 ave        4226 max        4226 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264202 ave      264202 max      264202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264202
Ave neighs/atom = 132.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.457489773153, Press = -0.728679589434638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -16041.739     -16041.739     -16111.896     -16111.896      271.51695      271.51695      36256.888      36256.888      906.61769      906.61769    
     57000  -16039.307     -16039.307     -16110.814     -16110.814      276.73715      276.73715      36299.076      36299.076     -889.74341     -889.74341    
Loop time of 148.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.345 hours/ns, 6.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.32     | 148.32     | 148.32     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09934    | 0.09934    | 0.09934    |   0.0 |  0.07
Output  | 0.00017344 | 0.00017344 | 0.00017344 |   0.0 |  0.00
Modify  | 0.36071    | 0.36071    | 0.36071    |   0.0 |  0.24
Other   |            | 0.05991    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4240 ave        4240 max        4240 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264852 ave      264852 max      264852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264852
Ave neighs/atom = 132.426
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.491170152831, Press = 0.582007234788532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -16039.307     -16039.307     -16110.814     -16110.814      276.73715      276.73715      36299.076      36299.076     -889.74341     -889.74341    
     58000  -16038.803     -16038.803     -16111.312     -16111.312      280.61889      280.61889      36316.69       36316.69      -1851.2315     -1851.2315    
Loop time of 148.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.276 hours/ns, 6.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.07     | 148.07     | 148.07     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10005    | 0.10005    | 0.10005    |   0.0 |  0.07
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.36067    | 0.36067    | 0.36067    |   0.0 |  0.24
Other   |            | 0.05946    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4274 ave        4274 max        4274 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264082 ave      264082 max      264082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264082
Ave neighs/atom = 132.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.48890130608, Press = -0.520044138126916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -16038.803     -16038.803     -16111.312     -16111.312      280.61889      280.61889      36316.69       36316.69      -1851.2315     -1851.2315    
     59000  -16040.757     -16040.757     -16110.155     -16110.155      268.57727      268.57727      36278.691      36278.691      288.09039      288.09039    
Loop time of 148.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.305 hours/ns, 6.725 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.18     | 148.18     | 148.18     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099915   | 0.099915   | 0.099915   |   0.0 |  0.07
Output  | 0.00017142 | 0.00017142 | 0.00017142 |   0.0 |  0.00
Modify  | 0.36089    | 0.36089    | 0.36089    |   0.0 |  0.24
Other   |            | 0.0598     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4259 ave        4259 max        4259 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263940 ave      263940 max      263940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263940
Ave neighs/atom = 131.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.475762875023, Press = -1.05423002146998
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -16040.757     -16040.757     -16110.155     -16110.155      268.57727      268.57727      36278.691      36278.691      288.09039      288.09039    
     60000  -16040.705     -16040.705     -16111.464     -16111.464      273.84433      273.84433      36293.995      36293.995     -828.29257     -828.29257    
Loop time of 148.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.376 hours/ns, 6.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.43     | 148.43     | 148.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10062    | 0.10062    | 0.10062    |   0.0 |  0.07
Output  | 0.00021609 | 0.00021609 | 0.00021609 |   0.0 |  0.00
Modify  | 0.36193    | 0.36193    | 0.36193    |   0.0 |  0.24
Other   |            | 0.05931    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4314 ave        4314 max        4314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264226 ave      264226 max      264226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264226
Ave neighs/atom = 132.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.425443782808, Press = -0.267366284741409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -16040.705     -16040.705     -16111.464     -16111.464      273.84433      273.84433      36293.995      36293.995     -828.29257     -828.29257    
     61000  -16039.778     -16039.778     -16112.05      -16112.05       279.70173      279.70173      36276.757      36276.757      60.401968      60.401968    
Loop time of 148.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.376 hours/ns, 6.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.43     | 148.43     | 148.43     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099276   | 0.099276   | 0.099276   |   0.0 |  0.07
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.36067    | 0.36067    | 0.36067    |   0.0 |  0.24
Other   |            | 0.05981    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4245 ave        4245 max        4245 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264530 ave      264530 max      264530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264530
Ave neighs/atom = 132.265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.392295107798, Press = -0.593026262696433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -16039.778     -16039.778     -16112.05      -16112.05       279.70173      279.70173      36276.757      36276.757      60.401968      60.401968    
     62000  -16042.021     -16042.021     -16112.264     -16112.264      271.84588      271.84588      36246.536      36246.536      1654.1987      1654.1987    
Loop time of 148.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.366 hours/ns, 6.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.4      | 148.4      | 148.4      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10025    | 0.10025    | 0.10025    |   0.0 |  0.07
Output  | 0.00017133 | 0.00017133 | 0.00017133 |   0.0 |  0.00
Modify  | 0.36159    | 0.36159    | 0.36159    |   0.0 |  0.24
Other   |            | 0.05958    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4270 ave        4270 max        4270 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264590 ave      264590 max      264590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264590
Ave neighs/atom = 132.295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.385295208549, Press = -0.693426971833558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -16042.021     -16042.021     -16112.264     -16112.264      271.84588      271.84588      36246.536      36246.536      1654.1987      1654.1987    
     63000  -16040.238     -16040.238     -16110.239     -16110.239      270.91348      270.91348      36260.934      36260.934      1183.5368      1183.5368    
Loop time of 149.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.439 hours/ns, 6.703 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.66     | 148.66     | 148.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10032    | 0.10032    | 0.10032    |   0.0 |  0.07
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.36227    | 0.36227    | 0.36227    |   0.0 |  0.24
Other   |            | 0.05946    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4290 ave        4290 max        4290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264594 ave      264594 max      264594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264594
Ave neighs/atom = 132.297
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386177544683, Press = 0.135263578047654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -16040.238     -16040.238     -16110.239     -16110.239      270.91348      270.91348      36260.934      36260.934      1183.5368      1183.5368    
     64000  -16041.171     -16041.171     -16111.975     -16111.975      274.02182      274.02182      36286.318      36286.318     -364.41086     -364.41086    
Loop time of 148.801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.334 hours/ns, 6.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.28     | 148.28     | 148.28     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10123    | 0.10123    | 0.10123    |   0.0 |  0.07
Output  | 0.00017117 | 0.00017117 | 0.00017117 |   0.0 |  0.00
Modify  | 0.36139    | 0.36139    | 0.36139    |   0.0 |  0.24
Other   |            | 0.05965    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4306 ave        4306 max        4306 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264412 ave      264412 max      264412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264412
Ave neighs/atom = 132.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.362973916569, Press = -1.02397902989555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -16041.171     -16041.171     -16111.975     -16111.975      274.02182      274.02182      36286.318      36286.318     -364.41086     -364.41086    
     65000  -16037.329     -16037.329     -16109.03      -16109.03       277.49054      277.49054      36229.674      36229.674      3098.1464      3098.1464    
Loop time of 148.682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.301 hours/ns, 6.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.16     | 148.16     | 148.16     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099317   | 0.099317   | 0.099317   |   0.0 |  0.07
Output  | 0.00017249 | 0.00017249 | 0.00017249 |   0.0 |  0.00
Modify  | 0.36031    | 0.36031    | 0.36031    |   0.0 |  0.24
Other   |            | 0.05947    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4263 ave        4263 max        4263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264198 ave      264198 max      264198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264198
Ave neighs/atom = 132.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.384689921277, Press = -0.449281642644071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -16037.329     -16037.329     -16109.03      -16109.03       277.49054      277.49054      36229.674      36229.674      3098.1464      3098.1464    
     66000  -16042.58      -16042.58      -16112.856     -16112.856      271.97746      271.97746      36275.504      36275.504     -111.68179     -111.68179    
Loop time of 149.154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.432 hours/ns, 6.704 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.63     | 148.63     | 148.63     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099983   | 0.099983   | 0.099983   |   0.0 |  0.07
Output  | 0.00016841 | 0.00016841 | 0.00016841 |   0.0 |  0.00
Modify  | 0.36079    | 0.36079    | 0.36079    |   0.0 |  0.24
Other   |            | 0.05965    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4278 ave        4278 max        4278 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264564 ave      264564 max      264564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264564
Ave neighs/atom = 132.282
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.390330028225, Press = -0.278292203834747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -16042.58      -16042.58      -16112.856     -16112.856      271.97746      271.97746      36275.504      36275.504     -111.68179     -111.68179    
     67000  -16038.68      -16038.68      -16111.055     -16111.055      280.09924      280.09924      36247.877      36247.877      1752.0388      1752.0388    
Loop time of 151.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.571 ns/day, 42.060 hours/ns, 6.604 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 150.88     | 150.88     | 150.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10153    | 0.10153    | 0.10153    |   0.0 |  0.07
Output  | 0.00017118 | 0.00017118 | 0.00017118 |   0.0 |  0.00
Modify  | 0.36904    | 0.36904    | 0.36904    |   0.0 |  0.24
Other   |            | 0.06044    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264362 ave      264362 max      264362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264362
Ave neighs/atom = 132.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386132338459, Press = -0.15421285127619
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -16038.68      -16038.68      -16111.055     -16111.055      280.09924      280.09924      36247.877      36247.877      1752.0388      1752.0388    
     68000  -16040.909     -16040.909     -16112.09      -16112.09       275.48008      275.48008      36311.001      36311.001     -1838.1309     -1838.1309    
Loop time of 156.722 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.551 ns/day, 43.534 hours/ns, 6.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.17     | 156.17     | 156.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10389    | 0.10389    | 0.10389    |   0.0 |  0.07
Output  | 0.00017117 | 0.00017117 | 0.00017117 |   0.0 |  0.00
Modify  | 0.38589    | 0.38589    | 0.38589    |   0.0 |  0.25
Other   |            | 0.06243    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264776 ave      264776 max      264776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264776
Ave neighs/atom = 132.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.379685454751, Press = -0.0518039989870939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -16040.909     -16040.909     -16112.09      -16112.09       275.48008      275.48008      36311.001      36311.001     -1838.1309     -1838.1309    
     69000  -16040.508     -16040.508     -16111.004     -16111.004      272.82785      272.82785      36291.952      36291.952     -516.72297     -516.72297    
Loop time of 149.024 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.396 hours/ns, 6.710 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099317   | 0.099317   | 0.099317   |   0.0 |  0.07
Output  | 0.00017072 | 0.00017072 | 0.00017072 |   0.0 |  0.00
Modify  | 0.36103    | 0.36103    | 0.36103    |   0.0 |  0.24
Other   |            | 0.05993    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4217 ave        4217 max        4217 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264316 ave      264316 max      264316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264316
Ave neighs/atom = 132.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.406729714862, Press = 0.0858821550561778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.136 | 4.136 | 4.136 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -16040.508     -16040.508     -16111.004     -16111.004      272.82785      272.82785      36291.952      36291.952     -516.72297     -516.72297    
     70000  -16036.597     -16036.597     -16109.441     -16109.441      281.91495      281.91495      36332.221      36332.221     -2205.4938     -2205.4938    
Loop time of 149.549 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.541 hours/ns, 6.687 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.03     | 149.03     | 149.03     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.07
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.3606     | 0.3606     | 0.3606     |   0.0 |  0.24
Other   |            | 0.06056    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4298 ave        4298 max        4298 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264332 ave      264332 max      264332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264332
Ave neighs/atom = 132.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.409088260313, Press = -0.458880166203889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -16036.597     -16036.597     -16109.441     -16109.441      281.91495      281.91495      36332.221      36332.221     -2205.4938     -2205.4938    
     71000  -16041.191     -16041.191     -16110.436     -16110.436      267.98766      267.98766      36254.844      36254.844      1446.3471      1446.3471    
Loop time of 149.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.399 hours/ns, 6.710 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.52     | 148.52     | 148.52     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099753   | 0.099753   | 0.099753   |   0.0 |  0.07
Output  | 0.00017204 | 0.00017204 | 0.00017204 |   0.0 |  0.00
Modify  | 0.36006    | 0.36006    | 0.36006    |   0.0 |  0.24
Other   |            | 0.05974    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4263 ave        4263 max        4263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263606 ave      263606 max      263606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263606
Ave neighs/atom = 131.803
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.426818890779, Press = -0.561785663156415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.135 | 4.135 | 4.135 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -16041.191     -16041.191     -16110.436     -16110.436      267.98766      267.98766      36254.844      36254.844      1446.3471      1446.3471    
     72000  -16042.758     -16042.758     -16112.691     -16112.691      270.64604      270.64604      36275.048      36275.048      10.514473      10.514473    
Loop time of 148.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.368 hours/ns, 6.715 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.41     | 148.41     | 148.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099834   | 0.099834   | 0.099834   |   0.0 |  0.07
Output  | 0.00020868 | 0.00020868 | 0.00020868 |   0.0 |  0.00
Modify  | 0.36027    | 0.36027    | 0.36027    |   0.0 |  0.24
Other   |            | 0.05941    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4246 ave        4246 max        4246 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264498 ave      264498 max      264498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264498
Ave neighs/atom = 132.249
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.445633045756, Press = 0.00159192396128871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -16042.758     -16042.758     -16112.691     -16112.691      270.64604      270.64604      36275.048      36275.048      10.514473      10.514473    
     73000  -16040.372     -16040.372     -16111.593     -16111.593      275.63294      275.63294      36259.541      36259.541      1223.0905      1223.0905    
Loop time of 148.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.272 hours/ns, 6.730 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.06     | 148.06     | 148.06     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10019    | 0.10019    | 0.10019    |   0.0 |  0.07
Output  | 0.00017088 | 0.00017088 | 0.00017088 |   0.0 |  0.00
Modify  | 0.36044    | 0.36044    | 0.36044    |   0.0 |  0.24
Other   |            | 0.05972    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4268 ave        4268 max        4268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264484 ave      264484 max      264484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264484
Ave neighs/atom = 132.242
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.426387708632, Press = -0.11518768905608
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -16040.372     -16040.372     -16111.593     -16111.593      275.63294      275.63294      36259.541      36259.541      1223.0905      1223.0905    
     74000  -16037.008     -16037.008     -16108.542     -16108.542      276.84391      276.84391      36285.524      36285.524      278.25352      278.25352    
Loop time of 149.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.416 hours/ns, 6.707 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.58     | 148.58     | 148.58     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10115    | 0.10115    | 0.10115    |   0.0 |  0.07
Output  | 0.00017294 | 0.00017294 | 0.00017294 |   0.0 |  0.00
Modify  | 0.36042    | 0.36042    | 0.36042    |   0.0 |  0.24
Other   |            | 0.05961    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4269 ave        4269 max        4269 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264662 ave      264662 max      264662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264662
Ave neighs/atom = 132.331
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.441854390245, Press = 0.372113039058863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -16037.008     -16037.008     -16108.542     -16108.542      276.84391      276.84391      36285.524      36285.524      278.25352      278.25352    
     75000  -16041.955     -16041.955     -16111.178     -16111.178      267.9025       267.9025       36315.962      36315.962     -1918.992      -1918.992     
Loop time of 148.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.290 hours/ns, 6.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.12     | 148.12     | 148.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.07
Output  | 0.00021489 | 0.00021489 | 0.00021489 |   0.0 |  0.00
Modify  | 0.36032    | 0.36032    | 0.36032    |   0.0 |  0.24
Other   |            | 0.05926    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4242 ave        4242 max        4242 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263848 ave      263848 max      263848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263848
Ave neighs/atom = 131.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.466567029297, Press = -0.707550114299306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -16041.955     -16041.955     -16111.178     -16111.178      267.9025       267.9025       36315.962      36315.962     -1918.992      -1918.992     
     76000  -16042.23      -16042.23      -16110.31      -16110.31       263.47768      263.47768      36244.38       36244.38       2177.7234      2177.7234    
Loop time of 149.109 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.419 hours/ns, 6.706 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.59     | 148.59     | 148.59     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10046    | 0.10046    | 0.10046    |   0.0 |  0.07
Output  | 0.0013519  | 0.0013519  | 0.0013519  |   0.0 |  0.00
Modify  | 0.36017    | 0.36017    | 0.36017    |   0.0 |  0.24
Other   |            | 0.05986    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4261 ave        4261 max        4261 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263980 ave      263980 max      263980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263980
Ave neighs/atom = 131.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459241173947, Press = 0.561558224515718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -16042.23      -16042.23      -16110.31      -16110.31       263.47768      263.47768      36244.38       36244.38       2177.7234      2177.7234    
     77000  -16040.082     -16040.082     -16111.846     -16111.846      277.7337       277.7337       36262.536      36262.536      881.23666      881.23666    
Loop time of 149.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.473 hours/ns, 6.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.78     | 148.78     | 148.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1003     | 0.1003     | 0.1003     |   0.0 |  0.07
Output  | 0.00018306 | 0.00018306 | 0.00018306 |   0.0 |  0.00
Modify  | 0.3606     | 0.3606     | 0.3606     |   0.0 |  0.24
Other   |            | 0.05993    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4277 ave        4277 max        4277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264422 ave      264422 max      264422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264422
Ave neighs/atom = 132.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.434432543962, Press = -0.454648904151455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -16040.082     -16040.082     -16111.846     -16111.846      277.7337       277.7337       36262.536      36262.536      881.23666      881.23666    
     78000  -16042.213     -16042.213     -16112.605     -16112.605      272.42615      272.42615      36280.804      36280.804     -190.61105     -190.61105    
Loop time of 148.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.355 hours/ns, 6.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.36     | 148.36     | 148.36     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10078    | 0.10078    | 0.10078    |   0.0 |  0.07
Output  | 0.00017116 | 0.00017116 | 0.00017116 |   0.0 |  0.00
Modify  | 0.36116    | 0.36116    | 0.36116    |   0.0 |  0.24
Other   |            | 0.05922    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4254 ave        4254 max        4254 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264528 ave      264528 max      264528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264528
Ave neighs/atom = 132.264
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.435707281357, Press = 0.0751960324241425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -16042.213     -16042.213     -16112.605     -16112.605      272.42615      272.42615      36280.804      36280.804     -190.61105     -190.61105    
     79000  -16041.977     -16041.977     -16112.98      -16112.98       274.79004      274.79004      36231.83       36231.83       2312.167       2312.167     
Loop time of 149.168 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.435 hours/ns, 6.704 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.65     | 148.65     | 148.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10013    | 0.10013    | 0.10013    |   0.0 |  0.07
Output  | 0.00021022 | 0.00021022 | 0.00021022 |   0.0 |  0.00
Modify  | 0.36095    | 0.36095    | 0.36095    |   0.0 |  0.24
Other   |            | 0.05971    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4256 ave        4256 max        4256 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264404 ave      264404 max      264404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264404
Ave neighs/atom = 132.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.462766342421, Press = -0.535044073386052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -16041.977     -16041.977     -16112.98      -16112.98       274.79004      274.79004      36231.83       36231.83       2312.167       2312.167     
     80000  -16041.433     -16041.433     -16110.658     -16110.658      267.90725      267.90725      36305.633      36305.633     -1317.6091     -1317.6091    
Loop time of 161.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.536 ns/day, 44.814 hours/ns, 6.198 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 160.76     | 160.76     | 160.76     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10665    | 0.10665    | 0.10665    |   0.0 |  0.07
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.3971     | 0.3971     | 0.3971     |   0.0 |  0.25
Other   |            | 0.06313    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4300 ave        4300 max        4300 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265006 ave      265006 max      265006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 265006
Ave neighs/atom = 132.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.454410117712, Press = 0.49083706061589
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -16041.433     -16041.433     -16110.658     -16110.658      267.90725      267.90725      36305.633      36305.633     -1317.6091     -1317.6091    
     81000  -16040.728     -16040.728     -16110.308     -16110.308      269.27939      269.27939      36293.399      36293.399     -555.78592     -555.78592    
Loop time of 157.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.757 hours/ns, 6.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 156.97     | 156.97     | 156.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10408    | 0.10408    | 0.10408    |   0.0 |  0.07
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.38942    | 0.38942    | 0.38942    |   0.0 |  0.25
Other   |            | 0.06246    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4317 ave        4317 max        4317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263834 ave      263834 max      263834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263834
Ave neighs/atom = 131.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.437764533072, Press = -0.347909869913542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -16040.728     -16040.728     -16110.308     -16110.308      269.27939      269.27939      36293.399      36293.399     -555.78592     -555.78592    
     82000  -16039.85      -16039.85      -16110.472     -16110.472      273.31361      273.31361      36266.957      36266.957      681.92235      681.92235    
Loop time of 147.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.104 hours/ns, 6.758 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    | 147.45     | 147.45     | 147.45     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09861    | 0.09861    | 0.09861    |   0.0 |  0.07
Output  | 0.00016771 | 0.00016771 | 0.00016771 |   0.0 |  0.00
Modify  | 0.36123    | 0.36123    | 0.36123    |   0.0 |  0.24
Other   |            | 0.0603     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4264 ave        4264 max        4264 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264180 ave      264180 max      264180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264180
Ave neighs/atom = 132.09
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.422719874237, Press = -0.255227678463289
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -16039.85      -16039.85      -16110.472     -16110.472      273.31361      273.31361      36266.957      36266.957      681.92235      681.92235    
     83000  -16041.35      -16041.35      -16111.156     -16111.156      270.15442      270.15442      36238.644      36238.644      2324.3521      2324.3521    
Loop time of 147.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.059 hours/ns, 6.765 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.29     | 147.29     | 147.29     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098848   | 0.098848   | 0.098848   |   0.0 |  0.07
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.35858    | 0.35858    | 0.35858    |   0.0 |  0.24
Other   |            | 0.05973    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4281 ave        4281 max        4281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264326 ave      264326 max      264326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264326
Ave neighs/atom = 132.163
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.419147305786, Press = 0.40509980641763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -16041.35      -16041.35      -16111.156     -16111.156      270.15442      270.15442      36238.644      36238.644      2324.3521      2324.3521    
     84000  -16039.423     -16039.423     -16111.263     -16111.263      278.02635      278.02635      36309.369      36309.369     -1697.6145     -1697.6145    
Loop time of 148.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.207 hours/ns, 6.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.83     | 147.83     | 147.83     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098611   | 0.098611   | 0.098611   |   0.0 |  0.07
Output  | 0.00017002 | 0.00017002 | 0.00017002 |   0.0 |  0.00
Modify  | 0.3582     | 0.3582     | 0.3582     |   0.0 |  0.24
Other   |            | 0.06074    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4288 ave        4288 max        4288 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264692 ave      264692 max      264692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264692
Ave neighs/atom = 132.346
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.399204203027, Press = -0.37523239579809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -16039.423     -16039.423     -16111.263     -16111.263      278.02635      278.02635      36309.369      36309.369     -1697.6145     -1697.6145    
     85000  -16039.175     -16039.175     -16111.453     -16111.453      279.72291      279.72291      36269.064      36269.064      669.44913      669.44913    
Loop time of 147.98 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.106 hours/ns, 6.758 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.46     | 147.46     | 147.46     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09797    | 0.09797    | 0.09797    |   0.0 |  0.07
Output  | 0.00016813 | 0.00016813 | 0.00016813 |   0.0 |  0.00
Modify  | 0.35838    | 0.35838    | 0.35838    |   0.0 |  0.24
Other   |            | 0.05992    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4257 ave        4257 max        4257 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263926 ave      263926 max      263926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263926
Ave neighs/atom = 131.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.39037863407, Press = -0.396339619404888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -16039.175     -16039.175     -16111.453     -16111.453      279.72291      279.72291      36269.064      36269.064      669.44913      669.44913    
     86000  -16036.797     -16036.797     -16109.263     -16109.263      280.45078      280.45078      36277.707      36277.707      490.09596      490.09596    
Loop time of 148.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.146 hours/ns, 6.751 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.61     | 147.61     | 147.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099012   | 0.099012   | 0.099012   |   0.0 |  0.07
Output  | 0.00021154 | 0.00021154 | 0.00021154 |   0.0 |  0.00
Modify  | 0.35986    | 0.35986    | 0.35986    |   0.0 |  0.24
Other   |            | 0.05989    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4307 ave        4307 max        4307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264344 ave      264344 max      264344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264344
Ave neighs/atom = 132.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.389876103628, Press = -0.246505225717038
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -16036.797     -16036.797     -16109.263     -16109.263      280.45078      280.45078      36277.707      36277.707      490.09596      490.09596    
     87000  -16040.731     -16040.731     -16112.065     -16112.065      276.07191      276.07191      36298.851      36298.851     -1136.3094     -1136.3094    
Loop time of 148.36 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.211 hours/ns, 6.740 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.84     | 147.84     | 147.84     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097492   | 0.097492   | 0.097492   |   0.0 |  0.07
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.36089    | 0.36089    | 0.36089    |   0.0 |  0.24
Other   |            | 0.06037    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4262 ave        4262 max        4262 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264270 ave      264270 max      264270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264270
Ave neighs/atom = 132.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.409940024584, Press = -0.335555863503136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -16040.731     -16040.731     -16112.065     -16112.065      276.07191      276.07191      36298.851      36298.851     -1136.3094     -1136.3094    
     88000  -16038.039     -16038.039     -16110.057     -16110.057      278.7186       278.7186       36277.212      36277.212      400.07279      400.07279    
Loop time of 148.265 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.185 hours/ns, 6.745 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.75     | 147.75     | 147.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09741    | 0.09741    | 0.09741    |   0.0 |  0.07
Output  | 0.00021611 | 0.00021611 | 0.00021611 |   0.0 |  0.00
Modify  | 0.3595     | 0.3595     | 0.3595     |   0.0 |  0.24
Other   |            | 0.05984    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4251 ave        4251 max        4251 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264276 ave      264276 max      264276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264276
Ave neighs/atom = 132.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.428034036652, Press = -0.0217268662780827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -16038.039     -16038.039     -16110.057     -16110.057      278.7186       278.7186       36277.212      36277.212      400.07279      400.07279    
     89000  -16041.121     -16041.121     -16110.911     -16110.911      270.09674      270.09674      36275.254      36275.254      319.67504      319.67504    
Loop time of 148.343 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.207 hours/ns, 6.741 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 147.82     | 147.82     | 147.82     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098361   | 0.098361   | 0.098361   |   0.0 |  0.07
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.36068    | 0.36068    | 0.36068    |   0.0 |  0.24
Other   |            | 0.05984    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4277 ave        4277 max        4277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264324 ave      264324 max      264324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264324
Ave neighs/atom = 132.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 = 273.421837678544, Press = -0.381650677932011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -16041.121     -16041.121     -16110.911     -16110.911      270.09674      270.09674      36275.254      36275.254      319.67504      319.67504    
     90000  -16040.926     -16040.926     -16111.293     -16111.293      272.32866      272.32866      36308.27       36308.27      -1245.6144     -1245.6144    
Loop time of 165.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.522 ns/day, 46.018 hours/ns, 6.036 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    | 165.08     | 165.08     | 165.08     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10746    | 0.10746    | 0.10746    |   0.0 |  0.06
Output  | 0.00020964 | 0.00020964 | 0.00020964 |   0.0 |  0.00
Modify  | 0.41308    | 0.41308    | 0.41308    |   0.0 |  0.25
Other   |            | 0.06452    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4281 ave        4281 max        4281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264204 ave      264204 max      264204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264204
Ave neighs/atom = 132.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.40593945522, Press = -0.256094114968053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -16040.926     -16040.926     -16111.293     -16111.293      272.32866      272.32866      36308.27       36308.27      -1245.6144     -1245.6144    
     91000  -16040.674     -16040.674     -16111.515     -16111.515      274.16438      274.16438      36218.07       36218.07       3177.6105      3177.6105    
Loop time of 157.65 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.792 hours/ns, 6.343 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    | 157.1      | 157.1      | 157.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10303    | 0.10303    | 0.10303    |   0.0 |  0.07
Output  | 0.00020791 | 0.00020791 | 0.00020791 |   0.0 |  0.00
Modify  | 0.3855     | 0.3855     | 0.3855     |   0.0 |  0.24
Other   |            | 0.06193    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4254 ave        4254 max        4254 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264056 ave      264056 max      264056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264056
Ave neighs/atom = 132.028
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.406448251682, Press = -0.54516106692039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -16040.674     -16040.674     -16111.515     -16111.515      274.16438      274.16438      36218.07       36218.07       3177.6105      3177.6105    
     92000  -16040.508     -16040.508     -16111.997     -16111.997      276.6709       276.6709       36265.959      36265.959      638.34866      638.34866    
Loop time of 171.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.749 hours/ns, 5.817 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    | 171.28     | 171.28     | 171.28     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1125     | 0.1125     | 0.1125     |   0.0 |  0.07
Output  | 0.00021583 | 0.00021583 | 0.00021583 |   0.0 |  0.00
Modify  | 0.43394    | 0.43394    | 0.43394    |   0.0 |  0.25
Other   |            | 0.0658     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4290 ave        4290 max        4290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264718 ave      264718 max      264718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264718
Ave neighs/atom = 132.359
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.398004411725, Press = 0.398774080535371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -16040.508     -16040.508     -16111.997     -16111.997      276.6709       276.6709       36265.959      36265.959      638.34866      638.34866    
     93000  -16040.591     -16040.591     -16110.921     -16110.921      272.18373      272.18373      36306.556      36306.556     -1167.6338     -1167.6338    
Loop time of 172.919 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.033 hours/ns, 5.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.3      | 172.3      | 172.3      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11297    | 0.11297    | 0.11297    |   0.0 |  0.07
Output  | 0.00016838 | 0.00016838 | 0.00016838 |   0.0 |  0.00
Modify  | 0.43897    | 0.43897    | 0.43897    |   0.0 |  0.25
Other   |            | 0.06594    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4268 ave        4268 max        4268 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264410 ave      264410 max      264410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264410
Ave neighs/atom = 132.205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.393359255189, Press = -0.288633795414265
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -16040.591     -16040.591     -16110.921     -16110.921      272.18373      272.18373      36306.556      36306.556     -1167.6338     -1167.6338    
     94000  -16040.981     -16040.981     -16112.44      -16112.44       276.55141      276.55141      36232.909      36232.909      2237.9126      2237.9126    
Loop time of 174.146 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.374 hours/ns, 5.742 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.52     | 173.52     | 173.52     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11262    | 0.11262    | 0.11262    |   0.0 |  0.06
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.44161    | 0.44161    | 0.44161    |   0.0 |  0.25
Other   |            | 0.0669     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4240 ave        4240 max        4240 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263986 ave      263986 max      263986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263986
Ave neighs/atom = 131.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 = 273.388020507445, Press = -0.188709452468357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -16040.981     -16040.981     -16112.44      -16112.44       276.55141      276.55141      36232.909      36232.909      2237.9126      2237.9126    
     95000  -16040.078     -16040.078     -16109.808     -16109.808      269.86172      269.86172      36291.202      36291.202     -365.42885     -365.42885    
Loop time of 155.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.554 ns/day, 43.313 hours/ns, 6.413 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.38     | 155.38     | 155.38     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10385    | 0.10385    | 0.10385    |   0.0 |  0.07
Output  | 0.00016969 | 0.00016969 | 0.00016969 |   0.0 |  0.00
Modify  | 0.38105    | 0.38105    | 0.38105    |   0.0 |  0.24
Other   |            | 0.06214    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264838 ave      264838 max      264838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264838
Ave neighs/atom = 132.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.379626642445, Press = -0.173689055217802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -16040.078     -16040.078     -16109.808     -16109.808      269.86172      269.86172      36291.202      36291.202     -365.42885     -365.42885    
     96000  -16043.147     -16043.147     -16112.72      -16112.72       269.25344      269.25344      36275.121      36275.121      14.588057      14.588057    
Loop time of 157.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.548 ns/day, 43.768 hours/ns, 6.347 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    | 157.01     | 157.01     | 157.01     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10439    | 0.10439    | 0.10439    |   0.0 |  0.07
Output  | 0.00020888 | 0.00020888 | 0.00020888 |   0.0 |  0.00
Modify  | 0.38883    | 0.38883    | 0.38883    |   0.0 |  0.25
Other   |            | 0.06294    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4294 ave        4294 max        4294 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263972 ave      263972 max      263972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263972
Ave neighs/atom = 131.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.399257348531, Press = -0.661012756533207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -16043.147     -16043.147     -16112.72      -16112.72       269.25344      269.25344      36275.121      36275.121      14.588057      14.588057    
     97000  -16038.977     -16038.977     -16110.656     -16110.656      277.40636      277.40636      36246.269      36246.269      1711.5736      1711.5736    
Loop time of 158.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.544 ns/day, 44.154 hours/ns, 6.291 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    | 158.4      | 158.4      | 158.4      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10506    | 0.10506    | 0.10506    |   0.0 |  0.07
Output  | 0.00023298 | 0.00023298 | 0.00023298 |   0.0 |  0.00
Modify  | 0.39019    | 0.39019    | 0.39019    |   0.0 |  0.25
Other   |            | 0.06319    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4285 ave        4285 max        4285 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264478 ave      264478 max      264478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264478
Ave neighs/atom = 132.239
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.412428327437, Press = -0.00313179368088866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -16038.977     -16038.977     -16110.656     -16110.656      277.40636      277.40636      36246.269      36246.269      1711.5736      1711.5736    
     98000  -16039.643     -16039.643     -16110.913     -16110.913      275.82244      275.82244      36310.664      36310.664     -1605.5327     -1605.5327    
Loop time of 175.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.876 hours/ns, 5.683 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    | 175.33     | 175.33     | 175.33     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11403    | 0.11403    | 0.11403    |   0.0 |  0.06
Output  | 0.00021644 | 0.00021644 | 0.00021644 |   0.0 |  0.00
Modify  | 0.44402    | 0.44402    | 0.44402    |   0.0 |  0.25
Other   |            | 0.06648    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4280 ave        4280 max        4280 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264672 ave      264672 max      264672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264672
Ave neighs/atom = 132.336
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.411368779067, Press = -0.4242557113282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -16039.643     -16039.643     -16110.913     -16110.913      275.82244      275.82244      36310.664      36310.664     -1605.5327     -1605.5327    
     99000  -16040.481     -16040.481     -16111.481     -16111.481      274.7759       274.7759       36262.488      36262.488      903.05492      903.05492    
Loop time of 175.588 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.775 hours/ns, 5.695 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    | 174.97     | 174.97     | 174.97     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11308    | 0.11308    | 0.11308    |   0.0 |  0.06
Output  | 0.00016916 | 0.00016916 | 0.00016916 |   0.0 |  0.00
Modify  | 0.44306    | 0.44306    | 0.44306    |   0.0 |  0.25
Other   |            | 0.06686    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4225 ave        4225 max        4225 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264182 ave      264182 max      264182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264182
Ave neighs/atom = 132.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.44054850914, Press = -0.188770525268617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -16040.481     -16040.481     -16111.481     -16111.481      274.7759       274.7759       36262.488      36262.488      903.05492      903.05492    
    100000  -16040.469     -16040.469     -16111.782     -16111.782      275.98718      275.98718      36294.507      36294.507     -870.64602     -870.64602    
Loop time of 168.795 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.888 hours/ns, 5.924 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    | 168.19     | 168.19     | 168.19     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10961    | 0.10961    | 0.10961    |   0.0 |  0.06
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.42458    | 0.42458    | 0.42458    |   0.0 |  0.25
Other   |            | 0.06683    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4260 ave        4260 max        4260 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264604 ave      264604 max      264604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264604
Ave neighs/atom = 132.302
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.440037453025, Press = -0.178089797819495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -16040.469     -16040.469     -16111.782     -16111.782      275.98718      275.98718      36294.507      36294.507     -870.64602     -870.64602    
    101000  -16040.359     -16040.359     -16110.208     -16110.208      270.32567      270.32567      36282.684      36282.684     -86.706302     -86.706302    
Loop time of 149.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.577 ns/day, 41.598 hours/ns, 6.678 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    | 149.23     | 149.23     | 149.23     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10033    | 0.10033    | 0.10033    |   0.0 |  0.07
Output  | 0.00016862 | 0.00016862 | 0.00016862 |   0.0 |  0.00
Modify  | 0.36422    | 0.36422    | 0.36422    |   0.0 |  0.24
Other   |            | 0.06107    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4273 ave        4273 max        4273 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264210 ave      264210 max      264210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264210
Ave neighs/atom = 132.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.473576142937, Press = -0.180832008879348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -16040.359     -16040.359     -16110.208     -16110.208      270.32567      270.32567      36282.684      36282.684     -86.706302     -86.706302    
    102000  -16042.143     -16042.143     -16111.322     -16111.322      267.72794      267.72794      36301.82       36301.82      -1237.5106     -1237.5106    
Loop time of 171.05 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.505 ns/day, 47.514 hours/ns, 5.846 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    | 170.44     | 170.44     | 170.44     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11254    | 0.11254    | 0.11254    |   0.0 |  0.07
Output  | 0.00028428 | 0.00028428 | 0.00028428 |   0.0 |  0.00
Modify  | 0.43269    | 0.43269    | 0.43269    |   0.0 |  0.25
Other   |            | 0.06683    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4269 ave        4269 max        4269 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264150 ave      264150 max      264150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264150
Ave neighs/atom = 132.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 = 273.475158370913, Press = -0.288376942055658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -16042.143     -16042.143     -16111.322     -16111.322      267.72794      267.72794      36301.82       36301.82      -1237.5106     -1237.5106    
    103000  -16038.85      -16038.85      -16109.809     -16109.809      274.61527      274.61527      36261.114      36261.114      1355.6498      1355.6498    
Loop time of 163.684 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.528 ns/day, 45.468 hours/ns, 6.109 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    | 163.1      | 163.1      | 163.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10732    | 0.10732    | 0.10732    |   0.0 |  0.07
Output  | 0.00021357 | 0.00021357 | 0.00021357 |   0.0 |  0.00
Modify  | 0.40832    | 0.40832    | 0.40832    |   0.0 |  0.25
Other   |            | 0.064      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4251 ave        4251 max        4251 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264120 ave      264120 max      264120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264120
Ave neighs/atom = 132.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.486461560516, Press = -0.220753749118468
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -16038.85      -16038.85      -16109.809     -16109.809      274.61527      274.61527      36261.114      36261.114      1355.6498      1355.6498    
    104000  -16040.227     -16040.227     -16111.918     -16111.918      277.45185      277.45185      36300.943      36300.943     -1178.6588     -1178.6588    
Loop time of 161.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.535 ns/day, 44.876 hours/ns, 6.190 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    | 160.99     | 160.99     | 160.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10494    | 0.10494    | 0.10494    |   0.0 |  0.06
Output  | 0.00016864 | 0.00016864 | 0.00016864 |   0.0 |  0.00
Modify  | 0.39806    | 0.39806    | 0.39806    |   0.0 |  0.25
Other   |            | 0.06424    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4262 ave        4262 max        4262 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264576 ave      264576 max      264576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264576
Ave neighs/atom = 132.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 = 273.482195156163, Press = -0.431418964020486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -16040.227     -16040.227     -16111.918     -16111.918      277.45185      277.45185      36300.943      36300.943     -1178.6588     -1178.6588    
    105000  -16041.2       -16041.2       -16111.964     -16111.964      273.86448      273.86448      36236.096      36236.096      2253.6217      2253.6217    
Loop time of 172.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.016 hours/ns, 5.785 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    | 172.24     | 172.24     | 172.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.06
Output  | 0.00016954 | 0.00016954 | 0.00016954 |   0.0 |  0.00
Modify  | 0.43825    | 0.43825    | 0.43825    |   0.0 |  0.25
Other   |            | 0.06638    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4275 ave        4275 max        4275 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264156 ave      264156 max      264156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264156
Ave neighs/atom = 132.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.50921517921, Press = 0.100921598187772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -16041.2       -16041.2       -16111.964     -16111.964      273.86448      273.86448      36236.096      36236.096      2253.6217      2253.6217    
    106000  -16040.103     -16040.103     -16109.535     -16109.535      268.71128      268.71128      36333.573      36333.573     -2426.9778     -2426.9778    
Loop time of 173.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.065 hours/ns, 5.779 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    | 172.42     | 172.42     | 172.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11255    | 0.11255    | 0.11255    |   0.0 |  0.07
Output  | 0.00021541 | 0.00021541 | 0.00021541 |   0.0 |  0.00
Modify  | 0.43727    | 0.43727    | 0.43727    |   0.0 |  0.25
Other   |            | 0.06717    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4272 ave        4272 max        4272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264826 ave      264826 max      264826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264826
Ave neighs/atom = 132.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.509371754504, Press = 0.064695121614676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -16040.103     -16040.103     -16109.535     -16109.535      268.71128      268.71128      36333.573      36333.573     -2426.9778     -2426.9778    
    107000  -16038.68      -16038.68      -16112.057     -16112.057      283.97705      283.97705      36251.064      36251.064      1451.6942      1451.6942    
Loop time of 176.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.904 hours/ns, 5.680 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    | 175.42     | 175.42     | 175.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11476    | 0.11476    | 0.11476    |   0.0 |  0.07
Output  | 0.00063914 | 0.00063914 | 0.00063914 |   0.0 |  0.00
Modify  | 0.4478     | 0.4478     | 0.4478     |   0.0 |  0.25
Other   |            | 0.06811    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4255 ave        4255 max        4255 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263682 ave      263682 max      263682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263682
Ave neighs/atom = 131.841
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.500894968484, Press = -0.167232984088626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.138 | 4.138 | 4.138 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -16038.68      -16038.68      -16112.057     -16112.057      283.97705      283.97705      36251.064      36251.064      1451.6942      1451.6942    
    108000  -16042.165     -16042.165     -16112.992     -16112.992      274.11101      274.11101      36307.332      36307.332     -1774.4612     -1774.4612    
Loop time of 173.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.180 hours/ns, 5.765 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    | 172.83     | 172.83     | 172.83     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11406    | 0.11406    | 0.11406    |   0.0 |  0.07
Output  | 0.0002258  | 0.0002258  | 0.0002258  |   0.0 |  0.00
Modify  | 0.43807    | 0.43807    | 0.43807    |   0.0 |  0.25
Other   |            | 0.06714    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4303 ave        4303 max        4303 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264672 ave      264672 max      264672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264672
Ave neighs/atom = 132.336
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.477633507369, Press = 0.162664277689193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -16042.165     -16042.165     -16112.992     -16112.992      274.11101      274.11101      36307.332      36307.332     -1774.4612     -1774.4612    
    109000  -16041.657     -16041.657     -16111.387     -16111.387      269.86316      269.86316      36250.49       36250.49       1325.7543      1325.7543    
Loop time of 168.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.925 hours/ns, 5.920 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    | 168.33     | 168.33     | 168.33     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11049    | 0.11049    | 0.11049    |   0.0 |  0.07
Output  | 0.00017175 | 0.00017175 | 0.00017175 |   0.0 |  0.00
Modify  | 0.42422    | 0.42422    | 0.42422    |   0.0 |  0.25
Other   |            | 0.06492    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4272 ave        4272 max        4272 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264352 ave      264352 max      264352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264352
Ave neighs/atom = 132.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.497062955606, Press = 0.0101055363011108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -16041.657     -16041.657     -16111.387     -16111.387      269.86316      269.86316      36250.49       36250.49       1325.7543      1325.7543    
    110000  -16039.672     -16039.672     -16110.152     -16110.152      272.76398      272.76398      36319.007      36319.007     -1926.6131     -1926.6131    
Loop time of 166.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.518 ns/day, 46.356 hours/ns, 5.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    | 166.29     | 166.29     | 166.29     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10889    | 0.10889    | 0.10889    |   0.0 |  0.07
Output  | 0.00021323 | 0.00021323 | 0.00021323 |   0.0 |  0.00
Modify  | 0.41896    | 0.41896    | 0.41896    |   0.0 |  0.25
Other   |            | 0.06439    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4241 ave        4241 max        4241 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264710 ave      264710 max      264710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264710
Ave neighs/atom = 132.355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.496847216582, Press = 0.0428189764108692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -16039.672     -16039.672     -16110.152     -16110.152      272.76398      272.76398      36319.007      36319.007     -1926.6131     -1926.6131    
    111000  -16041.749     -16041.749     -16112.107     -16112.107      272.29245      272.29245      36273.153      36273.153      421.87871      421.87871    
Loop time of 175.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.493 ns/day, 48.689 hours/ns, 5.705 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.65     | 174.65     | 174.65     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11498    | 0.11498    | 0.11498    |   0.0 |  0.07
Output  | 0.00017108 | 0.00017108 | 0.00017108 |   0.0 |  0.00
Modify  | 0.44776    | 0.44776    | 0.44776    |   0.0 |  0.26
Other   |            | 0.06734    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4274 ave        4274 max        4274 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263838 ave      263838 max      263838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263838
Ave neighs/atom = 131.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.482097941272, Press = -0.320963599947155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -16041.749     -16041.749     -16112.107     -16112.107      272.29245      272.29245      36273.153      36273.153      421.87871      421.87871    
    112000  -16039.78      -16039.78      -16111.536     -16111.536      277.70439      277.70439      36291.757      36291.757     -593.73744     -593.73744    
Loop time of 175.769 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.825 hours/ns, 5.689 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    | 175.14     | 175.14     | 175.14     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11635    | 0.11635    | 0.11635    |   0.0 |  0.07
Output  | 0.0001702  | 0.0001702  | 0.0001702  |   0.0 |  0.00
Modify  | 0.44906    | 0.44906    | 0.44906    |   0.0 |  0.26
Other   |            | 0.06689    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4300 ave        4300 max        4300 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264338 ave      264338 max      264338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264338
Ave neighs/atom = 132.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.488406649426, Press = -0.266059326932852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -16039.78      -16039.78      -16111.536     -16111.536      277.70439      277.70439      36291.757      36291.757     -593.73744     -593.73744    
    113000  -16040.98      -16040.98      -16110.757     -16110.757      270.04182      270.04182      36262.037      36262.037      1105.6016      1105.6016    
Loop time of 148.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.291 hours/ns, 6.727 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.12     | 148.12     | 148.12     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10133    | 0.10133    | 0.10133    |   0.0 |  0.07
Output  | 0.00016984 | 0.00016984 | 0.00016984 |   0.0 |  0.00
Modify  | 0.36135    | 0.36135    | 0.36135    |   0.0 |  0.24
Other   |            | 0.05939    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4292 ave        4292 max        4292 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264218 ave      264218 max      264218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264218
Ave neighs/atom = 132.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.476396139779, Press = -0.598645252020955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -16040.98      -16040.98      -16110.757     -16110.757      270.04182      270.04182      36262.037      36262.037      1105.6016      1105.6016    
    114000  -16038.408     -16038.408     -16110.087     -16110.087      277.4069       277.4069       36248.04       36248.04       2098.8067      2098.8067    
Loop time of 148.869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.352 hours/ns, 6.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.35     | 148.35     | 148.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10113    | 0.10113    | 0.10113    |   0.0 |  0.07
Output  | 0.00016896 | 0.00016896 | 0.00016896 |   0.0 |  0.00
Modify  | 0.36203    | 0.36203    | 0.36203    |   0.0 |  0.24
Other   |            | 0.059      |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4284 ave        4284 max        4284 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264518 ave      264518 max      264518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264518
Ave neighs/atom = 132.259
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.483976757726, Press = -0.0336155102323301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -16038.408     -16038.408     -16110.087     -16110.087      277.4069       277.4069       36248.04       36248.04       2098.8067      2098.8067    
    115000  -16041.512     -16041.512     -16110.762     -16110.762      268.00333      268.00333      36314.764      36314.764     -1736.6124     -1736.6124    
Loop time of 149.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.437 hours/ns, 6.704 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.65     | 148.65     | 148.65     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10175    | 0.10175    | 0.10175    |   0.0 |  0.07
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.36036    | 0.36036    | 0.36036    |   0.0 |  0.24
Other   |            | 0.05913    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4259 ave        4259 max        4259 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264552 ave      264552 max      264552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264552
Ave neighs/atom = 132.276
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.492691191521, Press = 0.106689903552596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -16041.512     -16041.512     -16110.762     -16110.762      268.00333      268.00333      36314.764      36314.764     -1736.6124     -1736.6124    
    116000  -16039.722     -16039.722     -16110.753     -16110.753      274.89677      274.89677      36250.551      36250.551      1744.6835      1744.6835    
Loop time of 148.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.378 hours/ns, 6.713 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.44     | 148.44     | 148.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10092    | 0.10092    | 0.10092    |   0.0 |  0.07
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.36118    | 0.36118    | 0.36118    |   0.0 |  0.24
Other   |            | 0.05965    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4283 ave        4283 max        4283 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263960 ave      263960 max      263960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263960
Ave neighs/atom = 131.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.485560120588, Press = -0.102519325470064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -16039.722     -16039.722     -16110.753     -16110.753      274.89677      274.89677      36250.551      36250.551      1744.6835      1744.6835    
    117000  -16041.898     -16041.898     -16112.023     -16112.023      271.39064      271.39064      36282.633      36282.633     -151.64019     -151.64019    
Loop time of 149.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.451 hours/ns, 6.701 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.7      | 148.7      | 148.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10083    | 0.10083    | 0.10083    |   0.0 |  0.07
Output  | 0.00016966 | 0.00016966 | 0.00016966 |   0.0 |  0.00
Modify  | 0.36106    | 0.36106    | 0.36106    |   0.0 |  0.24
Other   |            | 0.05931    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4277 ave        4277 max        4277 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264584 ave      264584 max      264584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264584
Ave neighs/atom = 132.292
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.46941920804, Press = -0.0160244098008753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -16041.898     -16041.898     -16112.023     -16112.023      271.39064      271.39064      36282.633      36282.633     -151.64019     -151.64019    
    118000  -16042.114     -16042.114     -16112.461     -16112.461      272.25208      272.25208      36269.757      36269.757      313.55711      313.55711    
Loop time of 148.802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.334 hours/ns, 6.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.28     | 148.28     | 148.28     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10065    | 0.10065    | 0.10065    |   0.0 |  0.07
Output  | 0.00017227 | 0.00017227 | 0.00017227 |   0.0 |  0.00
Modify  | 0.36071    | 0.36071    | 0.36071    |   0.0 |  0.24
Other   |            | 0.05898    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4256 ave        4256 max        4256 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264358 ave      264358 max      264358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264358
Ave neighs/atom = 132.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 = 273.469927965325, Press = 0.226854909591186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -16042.114     -16042.114     -16112.461     -16112.461      272.25208      272.25208      36269.757      36269.757      313.55711      313.55711    
    119000  -16036.966     -16036.966     -16111.143     -16111.143      287.07164      287.07164      36276.734      36276.734      229.48779      229.48779    
Loop time of 148.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.333 hours/ns, 6.720 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.28     | 148.28     | 148.28     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10042    | 0.10042    | 0.10042    |   0.0 |  0.07
Output  | 0.00021382 | 0.00021382 | 0.00021382 |   0.0 |  0.00
Modify  | 0.35979    | 0.35979    | 0.35979    |   0.0 |  0.24
Other   |            | 0.0594     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4251 ave        4251 max        4251 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264578 ave      264578 max      264578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264578
Ave neighs/atom = 132.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 = 273.478908454971, Press = -0.0149147182175348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -16036.966     -16036.966     -16111.143     -16111.143      287.07164      287.07164      36276.734      36276.734      229.48779      229.48779    
    120000  -16042.585     -16042.585     -16112.794     -16112.794      271.7164       271.7164       36252.488      36252.488      1154.8573      1154.8573    
Loop time of 148.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.359 hours/ns, 6.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.37     | 148.37     | 148.37     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.101      | 0.101      | 0.101      |   0.0 |  0.07
Output  | 0.00016895 | 0.00016895 | 0.00016895 |   0.0 |  0.00
Modify  | 0.36054    | 0.36054    | 0.36054    |   0.0 |  0.24
Other   |            | 0.05923    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4262 ave        4262 max        4262 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264166 ave      264166 max      264166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264166
Ave neighs/atom = 132.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.487230892237, Press = -0.244318456617743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -16042.585     -16042.585     -16112.794     -16112.794      271.7164       271.7164       36252.488      36252.488      1154.8573      1154.8573    
    121000  -16039.828     -16039.828     -16110.709     -16110.709      274.31669      274.31669      36310.533      36310.533     -1374.06       -1374.06      
Loop time of 149.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.576 ns/day, 41.647 hours/ns, 6.670 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.41     | 149.41     | 149.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10051    | 0.10051    | 0.10051    |   0.0 |  0.07
Output  | 0.00017095 | 0.00017095 | 0.00017095 |   0.0 |  0.00
Modify  | 0.36161    | 0.36161    | 0.36161    |   0.0 |  0.24
Other   |            | 0.05852    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4252 ave        4252 max        4252 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264952 ave      264952 max      264952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264952
Ave neighs/atom = 132.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.485313436322, Press = 0.00216681892294725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -16039.828     -16039.828     -16110.709     -16110.709      274.31669      274.31669      36310.533      36310.533     -1374.06       -1374.06      
    122000  -16042.151     -16042.151     -16110.824     -16110.824      265.76841      265.76841      36273.018      36273.018      396.8563       396.8563     
Loop time of 149.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.513 hours/ns, 6.691 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.93     | 148.93     | 148.93     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10036    | 0.10036    | 0.10036    |   0.0 |  0.07
Output  | 0.00016874 | 0.00016874 | 0.00016874 |   0.0 |  0.00
Modify  | 0.36151    | 0.36151    | 0.36151    |   0.0 |  0.24
Other   |            | 0.05877    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4241 ave        4241 max        4241 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263978 ave      263978 max      263978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263978
Ave neighs/atom = 131.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 = 273.469192437664, Press = -0.375393546300197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -16042.151     -16042.151     -16110.824     -16110.824      265.76841      265.76841      36273.018      36273.018      396.8563       396.8563     
    123000  -16041.162     -16041.162     -16111.472     -16111.472      272.10402      272.10402      36329.544      36329.544     -2527.627      -2527.627     
Loop time of 149.508 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.530 hours/ns, 6.689 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.99     | 148.99     | 148.99     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10082    | 0.10082    | 0.10082    |   0.0 |  0.07
Output  | 0.00017011 | 0.00017011 | 0.00017011 |   0.0 |  0.00
Modify  | 0.36113    | 0.36113    | 0.36113    |   0.0 |  0.24
Other   |            | 0.05965    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4285 ave        4285 max        4285 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264490 ave      264490 max      264490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264490
Ave neighs/atom = 132.245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.459245015158, Press = 0.0317188414258707
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -16041.162     -16041.162     -16111.472     -16111.472      272.10402      272.10402      36329.544      36329.544     -2527.627      -2527.627     
    124000  -16040.561     -16040.561     -16109.908     -16109.908      268.38157      268.38157      36249.903      36249.903      1646.753       1646.753     
Loop time of 149.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.470 hours/ns, 6.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.77     | 148.77     | 148.77     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10072    | 0.10072    | 0.10072    |   0.0 |  0.07
Output  | 0.00016995 | 0.00016995 | 0.00016995 |   0.0 |  0.00
Modify  | 0.36071    | 0.36071    | 0.36071    |   0.0 |  0.24
Other   |            | 0.05894    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4255 ave        4255 max        4255 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263806 ave      263806 max      263806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263806
Ave neighs/atom = 131.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.45229142292, Press = -0.120402706077215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -16040.561     -16040.561     -16109.908     -16109.908      268.38157      268.38157      36249.903      36249.903      1646.753       1646.753     
    125000  -16039.953     -16039.953     -16111.776     -16111.776      277.96147      277.96147      36266.49       36266.49       556.52518      556.52518    
Loop time of 148.907 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.363 hours/ns, 6.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.39     | 148.39     | 148.39     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10122    | 0.10122    | 0.10122    |   0.0 |  0.07
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.36078    | 0.36078    | 0.36078    |   0.0 |  0.24
Other   |            | 0.05937    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4278 ave        4278 max        4278 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264364 ave      264364 max      264364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264364
Ave neighs/atom = 132.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 = 273.428466321822, Press = -0.188797463865541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -16039.953     -16039.953     -16111.776     -16111.776      277.96147      277.96147      36266.49       36266.49       556.52518      556.52518    
    126000  -16040.641     -16040.641     -16111.887     -16111.887      275.73187      275.73187      36248.671      36248.671      1443.5697      1443.5697    
Loop time of 149.386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.496 hours/ns, 6.694 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.87     | 148.87     | 148.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10065    | 0.10065    | 0.10065    |   0.0 |  0.07
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.36027    | 0.36027    | 0.36027    |   0.0 |  0.24
Other   |            | 0.05878    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4255 ave        4255 max        4255 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264492 ave      264492 max      264492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264492
Ave neighs/atom = 132.246
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.417745172346, Press = -0.244951421961935
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -16040.641     -16040.641     -16111.887     -16111.887      275.73187      275.73187      36248.671      36248.671      1443.5697      1443.5697    
    127000  -16039.629     -16039.629     -16110.392     -16110.392      273.86139      273.86139      36281.835      36281.835      50.083839      50.083839    
Loop time of 149.296 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.579 ns/day, 41.471 hours/ns, 6.698 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.78     | 148.78     | 148.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10119    | 0.10119    | 0.10119    |   0.0 |  0.07
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.35999    | 0.35999    | 0.35999    |   0.0 |  0.24
Other   |            | 0.05924    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4285 ave        4285 max        4285 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264678 ave      264678 max      264678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264678
Ave neighs/atom = 132.339
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.397999152576, Press = -0.425770896440312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -16039.629     -16039.629     -16110.392     -16110.392      273.86139      273.86139      36281.835      36281.835      50.083839      50.083839    
    128000  -16042.292     -16042.292     -16112.226     -16112.226      270.65292      270.65292      36235.8        36235.8        2249.6569      2249.6569    
Loop time of 148.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.580 ns/day, 41.352 hours/ns, 6.717 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.34     | 148.34     | 148.34     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1017     | 0.1017     | 0.1017     |   0.0 |  0.07
Output  | 0.00017191 | 0.00017191 | 0.00017191 |   0.0 |  0.00
Modify  | 0.36092    | 0.36092    | 0.36092    |   0.0 |  0.24
Other   |            | 0.0595     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4293 ave        4293 max        4293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264118 ave      264118 max      264118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264118
Ave neighs/atom = 132.059
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.395804722021, Press = 0.0887946559724898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -16042.292     -16042.292     -16112.226     -16112.226      270.65292      270.65292      36235.8        36235.8        2249.6569      2249.6569    
    129000  -16040.96      -16040.96      -16111.45      -16111.45       272.80245      272.80245      36332.864      36332.864     -2831.0646     -2831.0646    
Loop time of 149.367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.491 hours/ns, 6.695 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.85     | 148.85     | 148.85     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10057    | 0.10057    | 0.10057    |   0.0 |  0.07
Output  | 0.00016997 | 0.00016997 | 0.00016997 |   0.0 |  0.00
Modify  | 0.36085    | 0.36085    | 0.36085    |   0.0 |  0.24
Other   |            | 0.05872    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4266 ave        4266 max        4266 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264976 ave      264976 max      264976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264976
Ave neighs/atom = 132.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.410465410216, Press = -0.883205243588058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -16040.96      -16040.96      -16111.45      -16111.45       272.80245      272.80245      36332.864      36332.864     -2831.0646     -2831.0646    
    130000  -16042.782     -16042.782     -16111.044     -16111.044      264.17913      264.17913      36287.452      36287.452     -452.13526     -452.13526    
Loop time of 158.123 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.546 ns/day, 43.923 hours/ns, 6.324 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    | 157.56     | 157.56     | 157.56     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10491    | 0.10491    | 0.10491    |   0.0 |  0.07
Output  | 0.00016829 | 0.00016829 | 0.00016829 |   0.0 |  0.00
Modify  | 0.39201    | 0.39201    | 0.39201    |   0.0 |  0.25
Other   |            | 0.06144    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4251 ave        4251 max        4251 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       263956 ave      263956 max      263956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263956
Ave neighs/atom = 131.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.377849345673, Press = -0.367918402253653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -16042.782     -16042.782     -16111.044     -16111.044      264.17913      264.17913      36287.452      36287.452     -452.13526     -452.13526    
    131000  -16040.944     -16040.944     -16110.786     -16110.786      270.29522      270.29522      36291.907      36291.907     -706.76681     -706.76681    
Loop time of 175.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.733 hours/ns, 5.700 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    | 174.81     | 174.81     | 174.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11392    | 0.11392    | 0.11392    |   0.0 |  0.06
Output  | 0.00016895 | 0.00016895 | 0.00016895 |   0.0 |  0.00
Modify  | 0.4442     | 0.4442     | 0.4442     |   0.0 |  0.25
Other   |            | 0.06619    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4249 ave        4249 max        4249 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264030 ave      264030 max      264030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264030
Ave neighs/atom = 132.015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.37084442239, Press = 0.090372669136928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -16040.944     -16040.944     -16110.786     -16110.786      270.29522      270.29522      36291.907      36291.907     -706.76681     -706.76681    
    132000  -16039.895     -16039.895     -16111.08      -16111.08       275.49171      275.49171      36307.731      36307.731     -1398.5227     -1398.5227    
Loop time of 175.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.850 hours/ns, 5.686 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    | 175.23     | 175.23     | 175.23     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11563    | 0.11563    | 0.11563    |   0.0 |  0.07
Output  | 0.00017165 | 0.00017165 | 0.00017165 |   0.0 |  0.00
Modify  | 0.44459    | 0.44459    | 0.44459    |   0.0 |  0.25
Other   |            | 0.06674    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4281 ave        4281 max        4281 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264254 ave      264254 max      264254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 264254
Ave neighs/atom = 132.127
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.358110049401, Press = -0.313434684677906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.137 | 4.137 | 4.137 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -16039.895     -16039.895     -16111.08      -16111.08       275.49171      275.49171      36307.731      36307.731     -1398.5227     -1398.5227    
    133000  -16042.245     -16042.245     -16110.757     -16110.757      265.14829      265.14829      36259.411      36259.411      1048.263       1048.263     
Loop time of 175.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.491 ns/day, 48.854 hours/ns, 5.686 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    | 175.24     | 175.24     | 175.24     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11515    | 0.11515    | 0.11515    |   0.0 |  0.07
Output  | 0.0002201  | 0.0002201  | 0.0002201  |   0.0 |  0.00
Modify  | 0.4478     | 0.4478     | 0.4478     |   0.0 |  0.25
Other   |            | 0.06647    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4263 ave        4263 max        4263 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264176 ave      264176 max      264176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0