# 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.889087237417698*${_u_distance}
variable latticeconst_converted equal 3.889087237417698*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.8890872374177
Lattice spacing in x,y,z = 3.8890872 3.8890872 3.8890872
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (38.890872 38.890872 38.890872)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (38.890872 38.890872 38.890872)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Pd

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

kim interactions Pd
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KoLee_2013_VPdY__MO_046547823135_002
pair_coeff * * Pd
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 106.42

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -15498.806     -15498.806     -15640         -15640          273.15         273.15         58822.443      58822.443      2563.8912      2563.8912    
      1000  -15358.613     -15358.613     -15499.149     -15499.149      271.87599      271.87599      59526.62       59526.62      -630.52914     -630.52914    
Loop time of 69.5623 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.242 ns/day, 19.323 hours/ns, 14.376 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    | 69.397     | 69.397     | 69.397     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03027    | 0.03027    | 0.03027    |   0.0 |  0.04
Output  | 0.00015706 | 0.00015706 | 0.00015706 |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   0.0 |  0.18
Other   |            | 0.0131     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       560000 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.173 ns/day, 20.468 hours/ns, 13.571 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    | 73.522     | 73.522     | 73.522     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030143   | 0.030143   | 0.030143   |   0.0 |  0.04
Output  | 6.1406e-05 | 6.1406e-05 | 6.1406e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.16
Other   |            | 0.01222    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559510 ave      559510 max      559510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.164 ns/day, 20.613 hours/ns, 13.476 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    | 74.045     | 74.045     | 74.045     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030233   | 0.030233   | 0.030233   |   0.0 |  0.04
Output  | 5.841e-05  | 5.841e-05  | 5.841e-05  |   0.0 |  0.00
Modify  | 0.12052    | 0.12052    | 0.12052    |   0.0 |  0.16
Other   |            | 0.01203    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559706 ave      559706 max      559706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.163 ns/day, 20.638 hours/ns, 13.460 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    | 74.133     | 74.133     | 74.133     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030011   | 0.030011   | 0.030011   |   0.0 |  0.04
Output  | 5.9903e-05 | 5.9903e-05 | 5.9903e-05 |   0.0 |  0.00
Modify  | 0.12084    | 0.12084    | 0.12084    |   0.0 |  0.16
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8182 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559592 ave      559592 max      559592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.161 ns/day, 20.672 hours/ns, 13.438 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    | 74.254     | 74.254     | 74.254     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030066   | 0.030066   | 0.030066   |   0.0 |  0.04
Output  | 4.4223e-05 | 4.4223e-05 | 4.4223e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.16
Other   |            | 0.01209    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559692 ave      559692 max      559692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.160 ns/day, 20.682 hours/ns, 13.431 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.287     | 74.287     | 74.287     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030198   | 0.030198   | 0.030198   |   0.0 |  0.04
Output  | 4.8792e-05 | 4.8792e-05 | 4.8792e-05 |   0.0 |  0.00
Modify  | 0.12563    | 0.12563    | 0.12563    |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559734 ave      559734 max      559734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559734
Ave neighs/atom = 139.9335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.121543298226, Press = -3.0237307236201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -15360.94      -15360.94      -15502.954     -15502.954      274.73738      274.73738      59480.341      59480.341      518.01414      518.01414    
      7000  -15362.909     -15362.909     -15502.534     -15502.534      270.11489      270.11489      59468.89       59468.89       914.25894      914.25894    
Loop time of 74.2766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.632 hours/ns, 13.463 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    | 74.109     | 74.109     | 74.109     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030257   | 0.030257   | 0.030257   |   0.0 |  0.04
Output  | 4.4865e-05 | 4.4865e-05 | 4.4865e-05 |   0.0 |  0.00
Modify  | 0.12495    | 0.12495    | 0.12495    |   0.0 |  0.17
Other   |            | 0.01203    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559640 ave      559640 max      559640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559640
Ave neighs/atom = 139.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.904852289453, Press = -14.2648791273751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -15362.909     -15362.909     -15502.534     -15502.534      270.11489      270.11489      59468.89       59468.89       914.25894      914.25894    
      8000  -15367.213     -15367.213     -15505.773     -15505.773      268.05404      268.05404      59475.984      59475.984      227.46088      227.46088    
Loop time of 74.2758 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.632 hours/ns, 13.463 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    | 74.108     | 74.108     | 74.108     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030108   | 0.030108   | 0.030108   |   0.0 |  0.04
Output  | 4.5746e-05 | 4.5746e-05 | 4.5746e-05 |   0.0 |  0.00
Modify  | 0.12538    | 0.12538    | 0.12538    |   0.0 |  0.17
Other   |            | 0.01211    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8181 ave        8181 max        8181 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559650 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.9125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.142676491169, Press = -15.9253651300679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -15367.213     -15367.213     -15505.773     -15505.773      268.05404      268.05404      59475.984      59475.984      227.46088      227.46088    
      9000  -15360.098     -15360.098     -15501.293     -15501.293      273.15149      273.15149      59524.679      59524.679     -686.46309     -686.46309    
Loop time of 74.4361 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.677 hours/ns, 13.434 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    | 74.269     | 74.269     | 74.269     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030224   | 0.030224   | 0.030224   |   0.0 |  0.04
Output  | 5.9953e-05 | 5.9953e-05 | 5.9953e-05 |   0.0 |  0.00
Modify  | 0.12525    | 0.12525    | 0.12525    |   0.0 |  0.17
Other   |            | 0.01204    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559680 ave      559680 max      559680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559680
Ave neighs/atom = 139.92
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839565691421, Press = -12.9231386931236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -15360.098     -15360.098     -15501.293     -15501.293      273.15149      273.15149      59524.679      59524.679     -686.46309     -686.46309    
     10000  -15362.534     -15362.534     -15504.009     -15504.009      273.69262      273.69262      59476.618      59476.618      590.29818      590.29818    
Loop time of 74.4924 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.692 hours/ns, 13.424 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    | 74.325     | 74.325     | 74.325     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030058   | 0.030058   | 0.030058   |   0.0 |  0.04
Output  | 4.4674e-05 | 4.4674e-05 | 4.4674e-05 |   0.0 |  0.00
Modify  | 0.12516    | 0.12516    | 0.12516    |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8178 ave        8178 max        8178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559552 ave      559552 max      559552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559552
Ave neighs/atom = 139.888
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.357653481279, Press = -9.61095329211691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -15362.534     -15362.534     -15504.009     -15504.009      273.69262      273.69262      59476.618      59476.618      590.29818      590.29818    
     11000  -15358.117     -15358.117     -15502.265     -15502.265      278.8643       278.8643       59538.164      59538.164     -1173.9331     -1173.9331    
Loop time of 74.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.677 hours/ns, 13.434 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    | 74.27      | 74.27      | 74.27      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030191   | 0.030191   | 0.030191   |   0.0 |  0.04
Output  | 4.4564e-05 | 4.4564e-05 | 4.4564e-05 |   0.0 |  0.00
Modify  | 0.12507    | 0.12507    | 0.12507    |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559648 ave      559648 max      559648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559648
Ave neighs/atom = 139.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390456182835, Press = 1.01242432662162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -15358.117     -15358.117     -15502.265     -15502.265      278.8643       278.8643       59538.164      59538.164     -1173.9331     -1173.9331    
     12000  -15363.051     -15363.051     -15504.778     -15504.778      274.1806       274.1806       59501.221      59501.221     -344.0004      -344.0004     
Loop time of 74.5738 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.715 hours/ns, 13.410 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    | 74.406     | 74.406     | 74.406     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030186   | 0.030186   | 0.030186   |   0.0 |  0.04
Output  | 4.785e-05  | 4.785e-05  | 4.785e-05  |   0.0 |  0.00
Modify  | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.17
Other   |            | 0.01207    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559538 ave      559538 max      559538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559538
Ave neighs/atom = 139.8845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.26896638145, Press = -9.1185549985766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -15363.051     -15363.051     -15504.778     -15504.778      274.1806       274.1806       59501.221      59501.221     -344.0004      -344.0004     
     13000  -15362.616     -15362.616     -15502.456     -15502.456      270.53023      270.53023      59477.425      59477.425      645.11254      645.11254    
Loop time of 74.3828 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.662 hours/ns, 13.444 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    | 74.215     | 74.215     | 74.215     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030229   | 0.030229   | 0.030229   |   0.0 |  0.04
Output  | 4.3422e-05 | 4.3422e-05 | 4.3422e-05 |   0.0 |  0.00
Modify  | 0.12516    | 0.12516    | 0.12516    |   0.0 |  0.17
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559650 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.9125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.259494441729, Press = -0.553747501565659
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -15362.616     -15362.616     -15502.456     -15502.456      270.53023      270.53023      59477.425      59477.425      645.11254      645.11254    
     14000  -15355.87      -15355.87      -15499.247     -15499.247      277.3722       277.3722       59529.719      59529.719     -556.48128     -556.48128    
Loop time of 74.4441 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.679 hours/ns, 13.433 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    | 74.276     | 74.276     | 74.276     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030329   | 0.030329   | 0.030329   |   0.0 |  0.04
Output  | 8.6553e-05 | 8.6553e-05 | 8.6553e-05 |   0.0 |  0.00
Modify  | 0.12546    | 0.12546    | 0.12546    |   0.0 |  0.17
Other   |            | 0.012      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559654 ave      559654 max      559654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559654
Ave neighs/atom = 139.9135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.239782693548, Press = -4.37167950332764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -15355.87      -15355.87      -15499.247     -15499.247      277.3722       277.3722       59529.719      59529.719     -556.48128     -556.48128    
     15000  -15364.021     -15364.021     -15504.158     -15504.158      271.10485      271.10485      59494.11       59494.11      -93.511131     -93.511131    
Loop time of 74.5967 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.721 hours/ns, 13.405 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    | 74.429     | 74.429     | 74.429     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0302     | 0.0302     | 0.0302     |   0.0 |  0.04
Output  | 5.0686e-05 | 5.0686e-05 | 5.0686e-05 |   0.0 |  0.00
Modify  | 0.1251     | 0.1251     | 0.1251     |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559560 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.306462496105, Press = -2.18715916704881
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -15364.021     -15364.021     -15504.158     -15504.158      271.10485      271.10485      59494.11       59494.11      -93.511131     -93.511131    
     16000  -15359.712     -15359.712     -15501.082     -15501.082      273.49048      273.49048      59544.779      59544.779     -1229.1721     -1229.1721    
Loop time of 74.4031 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.668 hours/ns, 13.440 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.236     | 74.236     | 74.236     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030073   | 0.030073   | 0.030073   |   0.0 |  0.04
Output  | 4.5766e-05 | 4.5766e-05 | 4.5766e-05 |   0.0 |  0.00
Modify  | 0.12511    | 0.12511    | 0.12511    |   0.0 |  0.17
Other   |            | 0.01194    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559632 ave      559632 max      559632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559632
Ave neighs/atom = 139.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474520834487, Press = -4.38165982063883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -15359.712     -15359.712     -15501.082     -15501.082      273.49048      273.49048      59544.779      59544.779     -1229.1721     -1229.1721    
     17000  -15364.339     -15364.339     -15504.697     -15504.697      271.53245      271.53245      59482.191      59482.191      255.02476      255.02476    
Loop time of 74.4579 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.683 hours/ns, 13.430 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    | 74.29      | 74.29      | 74.29      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030262   | 0.030262   | 0.030262   |   0.0 |  0.04
Output  | 4.5245e-05 | 4.5245e-05 | 4.5245e-05 |   0.0 |  0.00
Modify  | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.17
Other   |            | 0.012      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559540 ave      559540 max      559540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559540
Ave neighs/atom = 139.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416864724643, Press = -0.62704290731335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -15364.339     -15364.339     -15504.697     -15504.697      271.53245      271.53245      59482.191      59482.191      255.02476      255.02476    
     18000  -15360.917     -15360.917     -15503.308     -15503.308      275.46501      275.46501      59534.464      59534.464     -1259.7589     -1259.7589    
Loop time of 74.4615 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.684 hours/ns, 13.430 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    | 74.294     | 74.294     | 74.294     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030184   | 0.030184   | 0.030184   |   0.0 |  0.04
Output  | 5.5173e-05 | 5.5173e-05 | 5.5173e-05 |   0.0 |  0.00
Modify  | 0.12558    | 0.12558    | 0.12558    |   0.0 |  0.17
Other   |            | 0.01207    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559650 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.9125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.457120011671, Press = -3.49781715845613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -15360.917     -15360.917     -15503.308     -15503.308      275.46501      275.46501      59534.464      59534.464     -1259.7589     -1259.7589    
     19000  -15361.81      -15361.81      -15505.556     -15505.556      278.08784      278.08784      59438.204      59438.204      1668.4632      1668.4632    
Loop time of 74.2781 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.633 hours/ns, 13.463 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    | 74.111     | 74.111     | 74.111     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030084   | 0.030084   | 0.030084   |   0.0 |  0.04
Output  | 4.4805e-05 | 4.4805e-05 | 4.4805e-05 |   0.0 |  0.00
Modify  | 0.12487    | 0.12487    | 0.12487    |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8194 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559536 ave      559536 max      559536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559536
Ave neighs/atom = 139.884
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.424961954275, Press = -2.3124459490275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -15361.81      -15361.81      -15505.556     -15505.556      278.08784      278.08784      59438.204      59438.204      1668.4632      1668.4632    
     20000  -15358.219     -15358.219     -15502.763     -15502.763      279.63093      279.63093      59536.013      59536.013     -1223.0797     -1223.0797    
Loop time of 74.4097 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.669 hours/ns, 13.439 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    | 74.242     | 74.242     | 74.242     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030157   | 0.030157   | 0.030157   |   0.0 |  0.04
Output  | 4.5546e-05 | 4.5546e-05 | 4.5546e-05 |   0.0 |  0.00
Modify  | 0.12559    | 0.12559    | 0.12559    |   0.0 |  0.17
Other   |            | 0.01206    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559688 ave      559688 max      559688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559688
Ave neighs/atom = 139.922
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542657211583, Press = -1.22561958886525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -15358.219     -15358.219     -15502.763     -15502.763      279.63093      279.63093      59536.013      59536.013     -1223.0797     -1223.0797    
     21000  -15362.087     -15362.087     -15505.35      -15505.35       277.15125      277.15125      59515.307      59515.307     -784.91723     -784.91723    
Loop time of 74.4367 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.677 hours/ns, 13.434 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    | 74.27      | 74.27      | 74.27      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.029985   | 0.029985   | 0.029985   |   0.0 |  0.04
Output  | 4.5536e-05 | 4.5536e-05 | 4.5536e-05 |   0.0 |  0.00
Modify  | 0.12475    | 0.12475    | 0.12475    |   0.0 |  0.17
Other   |            | 0.01199    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559568 ave      559568 max      559568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559568
Ave neighs/atom = 139.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523899828366, Press = -5.70215363418819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -15362.087     -15362.087     -15505.35      -15505.35       277.15125      277.15125      59515.307      59515.307     -784.91723     -784.91723    
     22000  -15362.518     -15362.518     -15504.47      -15504.47       274.61407      274.61407      59472.077      59472.077      691.41173      691.41173    
Loop time of 74.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.689 hours/ns, 13.426 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    | 74.314     | 74.314     | 74.314     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030125   | 0.030125   | 0.030125   |   0.0 |  0.04
Output  | 4.3913e-05 | 4.3913e-05 | 4.3913e-05 |   0.0 |  0.00
Modify  | 0.12533    | 0.12533    | 0.12533    |   0.0 |  0.17
Other   |            | 0.01206    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8190 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559624 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.579862471147, Press = 0.147153729685467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -15362.518     -15362.518     -15504.47      -15504.47       274.61407      274.61407      59472.077      59472.077      691.41173      691.41173    
     23000  -15357.272     -15357.272     -15500.062     -15500.062      276.23631      276.23631      59502.826      59502.826      167.49941      167.49941    
Loop time of 74.3367 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.649 hours/ns, 13.452 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    | 74.169     | 74.169     | 74.169     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030173   | 0.030173   | 0.030173   |   0.0 |  0.04
Output  | 4.796e-05  | 4.796e-05  | 4.796e-05  |   0.0 |  0.00
Modify  | 0.12518    | 0.12518    | 0.12518    |   0.0 |  0.17
Other   |            | 0.01201    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559682 ave      559682 max      559682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559682
Ave neighs/atom = 139.9205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.604802212829, Press = -2.74177157909645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -15357.272     -15357.272     -15500.062     -15500.062      276.23631      276.23631      59502.826      59502.826      167.49941      167.49941    
     24000  -15362.051     -15362.051     -15503.553     -15503.553      273.74639      273.74639      59476.306      59476.306      647.45403      647.45403    
Loop time of 74.4838 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.690 hours/ns, 13.426 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    | 74.317     | 74.317     | 74.317     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030265   | 0.030265   | 0.030265   |   0.0 |  0.04
Output  | 4.6347e-05 | 4.6347e-05 | 4.6347e-05 |   0.0 |  0.00
Modify  | 0.12504    | 0.12504    | 0.12504    |   0.0 |  0.17
Other   |            | 0.01192    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559618 ave      559618 max      559618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559618
Ave neighs/atom = 139.9045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.615550668592, Press = -2.00654268895201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -15362.051     -15362.051     -15503.553     -15503.553      273.74639      273.74639      59476.306      59476.306      647.45403      647.45403    
     25000  -15360.336     -15360.336     -15502.063     -15502.063      274.18091      274.18091      59467.879      59467.879      1038.3329      1038.3329    
Loop time of 74.3745 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.660 hours/ns, 13.445 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    | 74.207     | 74.207     | 74.207     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03012    | 0.03012    | 0.03012    |   0.0 |  0.04
Output  | 6.6295e-05 | 6.6295e-05 | 6.6295e-05 |   0.0 |  0.00
Modify  | 0.12555    | 0.12555    | 0.12555    |   0.0 |  0.17
Other   |            | 0.01202    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559672 ave      559672 max      559672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559672
Ave neighs/atom = 139.918
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650629997157, Press = -0.672607850202783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -15360.336     -15360.336     -15502.063     -15502.063      274.18091      274.18091      59467.879      59467.879      1038.3329      1038.3329    
     26000  -15364.343     -15364.343     -15504.767     -15504.767      271.6611       271.6611       59526.786      59526.786     -1164.4545     -1164.4545    
Loop time of 74.3971 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.666 hours/ns, 13.441 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.229     | 74.229     | 74.229     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030022   | 0.030022   | 0.030022   |   0.0 |  0.04
Output  | 5.9061e-05 | 5.9061e-05 | 5.9061e-05 |   0.0 |  0.00
Modify  | 0.12567    | 0.12567    | 0.12567    |   0.0 |  0.17
Other   |            | 0.01214    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8180 ave        8180 max        8180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559664 ave      559664 max      559664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559664
Ave neighs/atom = 139.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.583852155367, Press = -1.45788714438689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -15364.343     -15364.343     -15504.767     -15504.767      271.6611       271.6611       59526.786      59526.786     -1164.4545     -1164.4545    
     27000  -15367.885     -15367.885     -15507.008     -15507.008      269.14156      269.14156      59446.928      59446.928      1160.6955      1160.6955    
Loop time of 74.3946 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.665 hours/ns, 13.442 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.227     | 74.227     | 74.227     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030288   | 0.030288   | 0.030288   |   0.0 |  0.04
Output  | 5.7979e-05 | 5.7979e-05 | 5.7979e-05 |   0.0 |  0.00
Modify  | 0.1255     | 0.1255     | 0.1255     |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8190 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559574 ave      559574 max      559574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559574
Ave neighs/atom = 139.8935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.552721128921, Press = -2.08956234347725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -15367.885     -15367.885     -15507.008     -15507.008      269.14156      269.14156      59446.928      59446.928      1160.6955      1160.6955    
     28000  -15360.278     -15360.278     -15502.756     -15502.756      275.63311      275.63311      59495.615      59495.615      187.31629      187.31629    
Loop time of 74.4124 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.670 hours/ns, 13.439 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    | 74.245     | 74.245     | 74.245     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030335   | 0.030335   | 0.030335   |   0.0 |  0.04
Output  | 5.4903e-05 | 5.4903e-05 | 5.4903e-05 |   0.0 |  0.00
Modify  | 0.12541    | 0.12541    | 0.12541    |   0.0 |  0.17
Other   |            | 0.01204    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559726 ave      559726 max      559726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559726
Ave neighs/atom = 139.9315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469833639192, Press = -0.222233649360393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -15360.278     -15360.278     -15502.756     -15502.756      275.63311      275.63311      59495.615      59495.615      187.31629      187.31629    
     29000  -15364.603     -15364.603     -15504.427     -15504.427      270.49916      270.49916      59543.728      59543.728     -1682.9253     -1682.9253    
Loop time of 74.4042 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.668 hours/ns, 13.440 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.237     | 74.237     | 74.237     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03022    | 0.03022    | 0.03022    |   0.0 |  0.04
Output  | 7.0453e-05 | 7.0453e-05 | 7.0453e-05 |   0.0 |  0.00
Modify  | 0.12522    | 0.12522    | 0.12522    |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559614 ave      559614 max      559614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559614
Ave neighs/atom = 139.9035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.411341369155, Press = -1.5112263747085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -15364.603     -15364.603     -15504.427     -15504.427      270.49916      270.49916      59543.728      59543.728     -1682.9253     -1682.9253    
     30000  -15362.52      -15362.52      -15503.372     -15503.372      272.48651      272.48651      59448.655      59448.655      1453.6268      1453.6268    
Loop time of 74.4855 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.690 hours/ns, 13.425 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    | 74.318     | 74.318     | 74.318     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03015    | 0.03015    | 0.03015    |   0.0 |  0.04
Output  | 5.7138e-05 | 5.7138e-05 | 5.7138e-05 |   0.0 |  0.00
Modify  | 0.12522    | 0.12522    | 0.12522    |   0.0 |  0.17
Other   |            | 0.01204    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559560 ave      559560 max      559560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559560
Ave neighs/atom = 139.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.457287734828, Press = -1.21474808931276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -15362.52      -15362.52      -15503.372     -15503.372      272.48651      272.48651      59448.655      59448.655      1453.6268      1453.6268    
     31000  -15359.796     -15359.796     -15501.075     -15501.075      273.31349      273.31349      59534.012      59534.012     -916.52562     -916.52562    
Loop time of 74.5373 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.705 hours/ns, 13.416 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.37      | 74.37      | 74.37      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03011    | 0.03011    | 0.03011    |   0.0 |  0.04
Output  | 5.6376e-05 | 5.6376e-05 | 5.6376e-05 |   0.0 |  0.00
Modify  | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.17
Other   |            | 0.012      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559550 ave      559550 max      559550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559550
Ave neighs/atom = 139.8875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.492332403159, Press = -0.534352493724689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -15359.796     -15359.796     -15501.075     -15501.075      273.31349      273.31349      59534.012      59534.012     -916.52562     -916.52562    
     32000  -15364.569     -15364.569     -15505.522     -15505.522      272.68258      272.68258      59487.386      59487.386     -7.5167182     -7.5167182    
Loop time of 74.4968 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.694 hours/ns, 13.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.329     | 74.329     | 74.329     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030134   | 0.030134   | 0.030134   |   0.0 |  0.04
Output  | 4.6727e-05 | 4.6727e-05 | 4.6727e-05 |   0.0 |  0.00
Modify  | 0.12507    | 0.12507    | 0.12507    |   0.0 |  0.17
Other   |            | 0.01207    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559586 ave      559586 max      559586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559586
Ave neighs/atom = 139.8965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.511890655154, Press = -2.26265587817648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -15364.569     -15364.569     -15505.522     -15505.522      272.68258      272.68258      59487.386      59487.386     -7.5167182     -7.5167182    
     33000  -15358.603     -15358.603     -15503.042     -15503.042      279.42863      279.42863      59431.498      59431.498      2140.5564      2140.5564    
Loop time of 74.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.684 hours/ns, 13.430 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    | 74.293     | 74.293     | 74.293     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030207   | 0.030207   | 0.030207   |   0.0 |  0.04
Output  | 5.7148e-05 | 5.7148e-05 | 5.7148e-05 |   0.0 |  0.00
Modify  | 0.12553    | 0.12553    | 0.12553    |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559648 ave      559648 max      559648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559648
Ave neighs/atom = 139.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.531292709002, Press = 0.668317740158266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -15358.603     -15358.603     -15503.042     -15503.042      279.42863      279.42863      59431.498      59431.498      2140.5564      2140.5564    
     34000  -15367.321     -15367.321     -15506.593     -15506.593      269.42968      269.42968      59502.66       59502.66      -590.4407      -590.4407     
Loop time of 74.4435 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.679 hours/ns, 13.433 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    | 74.276     | 74.276     | 74.276     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030155   | 0.030155   | 0.030155   |   0.0 |  0.04
Output  | 5.9522e-05 | 5.9522e-05 | 5.9522e-05 |   0.0 |  0.00
Modify  | 0.1254     | 0.1254     | 0.1254     |   0.0 |  0.17
Other   |            | 0.0121     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8194 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559664 ave      559664 max      559664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559664
Ave neighs/atom = 139.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483205504587, Press = -1.85746797183137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -15367.321     -15367.321     -15506.593     -15506.593      269.42968      269.42968      59502.66       59502.66      -590.4407      -590.4407     
     35000  -15364.37      -15364.37      -15505.306     -15505.306      272.64988      272.64988      59471.134      59471.134      636.46415      636.46415    
Loop time of 74.2674 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.630 hours/ns, 13.465 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.1       | 74.1       | 74.1       |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030152   | 0.030152   | 0.030152   |   0.0 |  0.04
Output  | 5.4362e-05 | 5.4362e-05 | 5.4362e-05 |   0.0 |  0.00
Modify  | 0.1252     | 0.1252     | 0.1252     |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559626 ave      559626 max      559626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559626
Ave neighs/atom = 139.9065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.467183763371, Press = -1.07822983997323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -15364.37      -15364.37      -15505.306     -15505.306      272.64988      272.64988      59471.134      59471.134      636.46415      636.46415    
     36000  -15356.271     -15356.271     -15501.735     -15501.735      281.40939      281.40939      59529.002      59529.002     -747.77264     -747.77264    
Loop time of 74.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.700 hours/ns, 13.419 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    | 74.353     | 74.353     | 74.353     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030194   | 0.030194   | 0.030194   |   0.0 |  0.04
Output  | 5.9652e-05 | 5.9652e-05 | 5.9652e-05 |   0.0 |  0.00
Modify  | 0.12561    | 0.12561    | 0.12561    |   0.0 |  0.17
Other   |            | 0.01199    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559630 ave      559630 max      559630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559630
Ave neighs/atom = 139.9075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.507907336398, Press = -1.33663811875274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -15356.271     -15356.271     -15501.735     -15501.735      281.40939      281.40939      59529.002      59529.002     -747.77264     -747.77264    
     37000  -15363.794     -15363.794     -15504.563     -15504.563      272.32719      272.32719      59501.586      59501.586     -356.45106     -356.45106    
Loop time of 74.4958 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.693 hours/ns, 13.424 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.328     | 74.328     | 74.328     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030321   | 0.030321   | 0.030321   |   0.0 |  0.04
Output  | 5.4963e-05 | 5.4963e-05 | 5.4963e-05 |   0.0 |  0.00
Modify  | 0.12558    | 0.12558    | 0.12558    |   0.0 |  0.17
Other   |            | 0.01209    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559600 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.527456141915, Press = -0.925419193619979
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -15363.794     -15363.794     -15504.563     -15504.563      272.32719      272.32719      59501.586      59501.586     -356.45106     -356.45106    
     38000  -15361.462     -15361.462     -15502.157     -15502.157      272.18374      272.18374      59581.411      59581.411     -2598.3289     -2598.3289    
Loop time of 74.4911 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.692 hours/ns, 13.424 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.323     | 74.323     | 74.323     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030229   | 0.030229   | 0.030229   |   0.0 |  0.04
Output  | 5.846e-05  | 5.846e-05  | 5.846e-05  |   0.0 |  0.00
Modify  | 0.12539    | 0.12539    | 0.12539    |   0.0 |  0.17
Other   |            | 0.01207    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8190 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559650 ave      559650 max      559650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559650
Ave neighs/atom = 139.9125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.506055040525, Press = 0.0977225414947798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -15361.462     -15361.462     -15502.157     -15502.157      272.18374      272.18374      59581.411      59581.411     -2598.3289     -2598.3289    
     39000  -15363.03      -15363.03      -15503.309     -15503.309      271.38095      271.38095      59486.575      59486.575      194.79603      194.79603    
Loop time of 74.4893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.691 hours/ns, 13.425 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    | 74.322     | 74.322     | 74.322     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0302     | 0.0302     | 0.0302     |   0.0 |  0.04
Output  | 5.8339e-05 | 5.8339e-05 | 5.8339e-05 |   0.0 |  0.00
Modify  | 0.12536    | 0.12536    | 0.12536    |   0.0 |  0.17
Other   |            | 0.0121     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559494 ave      559494 max      559494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559494
Ave neighs/atom = 139.8735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.51077692828, Press = -1.85706016394983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -15363.03      -15363.03      -15503.309     -15503.309      271.38095      271.38095      59486.575      59486.575      194.79603      194.79603    
     40000  -15360.499     -15360.499     -15502.242     -15502.242      274.21249      274.21249      59479.215      59479.215      624.584        624.584      
Loop time of 74.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.697 hours/ns, 13.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.343     | 74.343     | 74.343     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030326   | 0.030326   | 0.030326   |   0.0 |  0.04
Output  | 6.8058e-05 | 6.8058e-05 | 6.8058e-05 |   0.0 |  0.00
Modify  | 0.12563    | 0.12563    | 0.12563    |   0.0 |  0.17
Other   |            | 0.01208    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8187 ave        8187 max        8187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559590 ave      559590 max      559590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559590
Ave neighs/atom = 139.8975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.501791094004, Press = -0.899792782728392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -15360.499     -15360.499     -15502.242     -15502.242      274.21249      274.21249      59479.215      59479.215      624.584        624.584      
     41000  -15362.654     -15362.654     -15504.679     -15504.679      274.7562       274.7562       59544.886      59544.886     -1738.0376     -1738.0376    
Loop time of 74.5106 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.697 hours/ns, 13.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.343     | 74.343     | 74.343     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030069   | 0.030069   | 0.030069   |   0.0 |  0.04
Output  | 5.4593e-05 | 5.4593e-05 | 5.4593e-05 |   0.0 |  0.00
Modify  | 0.12523    | 0.12523    | 0.12523    |   0.0 |  0.17
Other   |            | 0.01198    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8182 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559572 ave      559572 max      559572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559572
Ave neighs/atom = 139.893
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.505624620262, Press = -0.836436722459369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -15362.654     -15362.654     -15504.679     -15504.679      274.7562       274.7562       59544.886      59544.886     -1738.0376     -1738.0376    
     42000  -15359.865     -15359.865     -15502.528     -15502.528      275.98997      275.98997      59498.296      59498.296      29.995765      29.995765    
Loop time of 74.4896 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.692 hours/ns, 13.425 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    | 74.322     | 74.322     | 74.322     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030302   | 0.030302   | 0.030302   |   0.0 |  0.04
Output  | 5.4272e-05 | 5.4272e-05 | 5.4272e-05 |   0.0 |  0.00
Modify  | 0.12518    | 0.12518    | 0.12518    |   0.0 |  0.17
Other   |            | 0.01197    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559518 ave      559518 max      559518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559518
Ave neighs/atom = 139.8795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.536640266621, Press = -1.26938250405913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -15359.865     -15359.865     -15502.528     -15502.528      275.98997      275.98997      59498.296      59498.296      29.995765      29.995765    
     43000  -15361.831     -15361.831     -15503.781     -15503.781      274.61284      274.61284      59546.077      59546.077     -1617.5255     -1617.5255    
Loop time of 74.3017 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.639 hours/ns, 13.459 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    | 74.134     | 74.134     | 74.134     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030013   | 0.030013   | 0.030013   |   0.0 |  0.04
Output  | 6.2698e-05 | 6.2698e-05 | 6.2698e-05 |   0.0 |  0.00
Modify  | 0.12529    | 0.12529    | 0.12529    |   0.0 |  0.17
Other   |            | 0.01217    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559616 ave      559616 max      559616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559616
Ave neighs/atom = 139.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.528709932735, Press = -0.379303177141398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -15361.831     -15361.831     -15503.781     -15503.781      274.61284      274.61284      59546.077      59546.077     -1617.5255     -1617.5255    
     44000  -15368.711     -15368.711     -15508.476     -15508.476      270.38477      270.38477      59430.342      59430.342      1355.6603      1355.6603    
Loop time of 74.3265 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.162 ns/day, 20.646 hours/ns, 13.454 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.159     | 74.159     | 74.159     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030124   | 0.030124   | 0.030124   |   0.0 |  0.04
Output  | 5.9542e-05 | 5.9542e-05 | 5.9542e-05 |   0.0 |  0.00
Modify  | 0.12543    | 0.12543    | 0.12543    |   0.0 |  0.17
Other   |            | 0.01205    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8183 ave        8183 max        8183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559566 ave      559566 max      559566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559566
Ave neighs/atom = 139.8915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.517733026909, Press = -1.77790538522306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -15368.711     -15368.711     -15508.476     -15508.476      270.38477      270.38477      59430.342      59430.342      1355.6603      1355.6603    
     45000  -15361.828     -15361.828     -15504.452     -15504.452      275.9164       275.9164       59519.212      59519.212     -949.20262     -949.20262    
Loop time of 74.5642 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.712 hours/ns, 13.411 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.396     | 74.396     | 74.396     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030295   | 0.030295   | 0.030295   |   0.0 |  0.04
Output  | 5.7519e-05 | 5.7519e-05 | 5.7519e-05 |   0.0 |  0.00
Modify  | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.17
Other   |            | 0.01212    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559714 ave      559714 max      559714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559714
Ave neighs/atom = 139.9285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.474923557056, Press = -0.531944547198993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -15361.828     -15361.828     -15504.452     -15504.452      275.9164       275.9164       59519.212      59519.212     -949.20262     -949.20262    
     46000  -15361.434     -15361.434     -15503.039     -15503.039      273.94418      273.94418      59460.076      59460.076      1188.5646      1188.5646    
Loop time of 74.2939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.637 hours/ns, 13.460 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.127     | 74.127     | 74.127     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030127   | 0.030127   | 0.030127   |   0.0 |  0.04
Output  | 5.7087e-05 | 5.7087e-05 | 5.7087e-05 |   0.0 |  0.00
Modify  | 0.12495    | 0.12495    | 0.12495    |   0.0 |  0.17
Other   |            | 0.01204    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559616 ave      559616 max      559616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559616
Ave neighs/atom = 139.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.473813350716, Press = -1.82353538278151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -15361.434     -15361.434     -15503.039     -15503.039      273.94418      273.94418      59460.076      59460.076      1188.5646      1188.5646    
     47000  -15361.241     -15361.241     -15502.273     -15502.273      272.83534      272.83534      59489.234      59489.234      310.03107      310.03107    
Loop time of 74.4691 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.686 hours/ns, 13.428 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.302     | 74.302     | 74.302     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030171   | 0.030171   | 0.030171   |   0.0 |  0.04
Output  | 5.5835e-05 | 5.5835e-05 | 5.5835e-05 |   0.0 |  0.00
Modify  | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.17
Other   |            | 0.0121     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559716 ave      559716 max      559716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559716
Ave neighs/atom = 139.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.502169209323, Press = 0.187172842584364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -15361.241     -15361.241     -15502.273     -15502.273      272.83534      272.83534      59489.234      59489.234      310.03107      310.03107    
     48000  -15361.183     -15361.183     -15503.162     -15503.162      274.66807      274.66807      59518.088      59518.088     -670.19395     -670.19395    
Loop time of 74.5008 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.695 hours/ns, 13.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.333     | 74.333     | 74.333     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030133   | 0.030133   | 0.030133   |   0.0 |  0.04
Output  | 5.5595e-05 | 5.5595e-05 | 5.5595e-05 |   0.0 |  0.00
Modify  | 0.12548    | 0.12548    | 0.12548    |   0.0 |  0.17
Other   |            | 0.01223    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559656 ave      559656 max      559656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559656
Ave neighs/atom = 139.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.486374519901, Press = -1.37115884427228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -15361.183     -15361.183     -15503.162     -15503.162      274.66807      274.66807      59518.088      59518.088     -670.19395     -670.19395    
     49000  -15367.814     -15367.814     -15505.642     -15505.642      266.63725      266.63725      59457.738      59457.738      918.85053      918.85053    
Loop time of 74.2556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.627 hours/ns, 13.467 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.088     | 74.088     | 74.088     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030071   | 0.030071   | 0.030071   |   0.0 |  0.04
Output  | 5.7799e-05 | 5.7799e-05 | 5.7799e-05 |   0.0 |  0.00
Modify  | 0.12525    | 0.12525    | 0.12525    |   0.0 |  0.17
Other   |            | 0.01204    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8190 ave        8190 max        8190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559534 ave      559534 max      559534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559534
Ave neighs/atom = 139.8835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.449954457483, Press = -0.261372625831744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -15367.814     -15367.814     -15505.642     -15505.642      266.63725      266.63725      59457.738      59457.738      918.85053      918.85053    
     50000  -15362.056     -15362.056     -15504.171     -15504.171      274.93213      274.93213      59525.655      59525.655     -1168.9886     -1168.9886    
Loop time of 74.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.680 hours/ns, 13.432 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    | 74.28      | 74.28      | 74.28      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030348   | 0.030348   | 0.030348   |   0.0 |  0.04
Output  | 5.4562e-05 | 5.4562e-05 | 5.4562e-05 |   0.0 |  0.00
Modify  | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.17
Other   |            | 0.01206    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8194 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559702 ave      559702 max      559702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559702
Ave neighs/atom = 139.9255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.439569011805, Press = -0.689343085452612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -15362.056     -15362.056     -15504.171     -15504.171      274.93213      274.93213      59525.655      59525.655     -1168.9886     -1168.9886    
     51000  -15363.794     -15363.794     -15505.05      -15505.05       273.26846      273.26846      59493.505      59493.505     -141.01907     -141.01907    
Loop time of 74.5156 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.699 hours/ns, 13.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.348     | 74.348     | 74.348     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030093   | 0.030093   | 0.030093   |   0.0 |  0.04
Output  | 5.6346e-05 | 5.6346e-05 | 5.6346e-05 |   0.0 |  0.00
Modify  | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.17
Other   |            | 0.01214    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559608 ave      559608 max      559608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559608
Ave neighs/atom = 139.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445306079494, Press = -0.673131001116556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -15363.794     -15363.794     -15505.05      -15505.05       273.26846      273.26846      59493.505      59493.505     -141.01907     -141.01907    
     52000  -15365.233     -15365.233     -15506.107     -15506.107      272.53058      272.53058      59498.605      59498.605     -540.68751     -540.68751    
Loop time of 74.2293 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.619 hours/ns, 13.472 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.062     | 74.062     | 74.062     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030102   | 0.030102   | 0.030102   |   0.0 |  0.04
Output  | 5.6135e-05 | 5.6135e-05 | 5.6135e-05 |   0.0 |  0.00
Modify  | 0.12488    | 0.12488    | 0.12488    |   0.0 |  0.17
Other   |            | 0.01212    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559638 ave      559638 max      559638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559638
Ave neighs/atom = 139.9095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.448950613298, Press = -1.01776908937866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -15365.233     -15365.233     -15506.107     -15506.107      272.53058      272.53058      59498.605      59498.605     -540.68751     -540.68751    
     53000  -15361.82      -15361.82      -15502.699     -15502.699      272.53959      272.53959      59484.411      59484.411      401.15134      401.15134    
Loop time of 74.3213 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.645 hours/ns, 13.455 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    | 74.153     | 74.153     | 74.153     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030131   | 0.030131   | 0.030131   |   0.0 |  0.04
Output  | 4.781e-05  | 4.781e-05  | 4.781e-05  |   0.0 |  0.00
Modify  | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.17
Other   |            | 0.01214    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8192 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559600 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397089259563, Press = -1.30368523249874
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -15361.82      -15361.82      -15502.699     -15502.699      272.53959      272.53959      59484.411      59484.411      401.15134      401.15134    
     54000  -15359.842     -15359.842     -15502.669     -15502.669      276.30921      276.30921      59486.739      59486.739      305.25876      305.25876    
Loop time of 74.5598 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.711 hours/ns, 13.412 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    | 74.392     | 74.392     | 74.392     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03029    | 0.03029    | 0.03029    |   0.0 |  0.04
Output  | 5.8761e-05 | 5.8761e-05 | 5.8761e-05 |   0.0 |  0.00
Modify  | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.17
Other   |            | 0.01209    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8185 ave        8185 max        8185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559614 ave      559614 max      559614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559614
Ave neighs/atom = 139.9035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.39207349564, Press = 0.354774801681455
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -15359.842     -15359.842     -15502.669     -15502.669      276.30921      276.30921      59486.739      59486.739      305.25876      305.25876    
     55000  -15364.435     -15364.435     -15504.277     -15504.277      270.53463      270.53463      59504.421      59504.421     -375.82034     -375.82034    
Loop time of 74.1945 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.610 hours/ns, 13.478 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.028     | 74.028     | 74.028     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030002   | 0.030002   | 0.030002   |   0.0 |  0.04
Output  | 5.8249e-05 | 5.8249e-05 | 5.8249e-05 |   0.0 |  0.00
Modify  | 0.12476    | 0.12476    | 0.12476    |   0.0 |  0.17
Other   |            | 0.01212    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8191 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559600 ave      559600 max      559600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559600
Ave neighs/atom = 139.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399917090493, Press = -0.81933784538347
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -15364.435     -15364.435     -15504.277     -15504.277      270.53463      270.53463      59504.421      59504.421     -375.82034     -375.82034    
     56000  -15361.115     -15361.115     -15505.114     -15505.114      278.57682      278.57682      59484.265      59484.265      153.69823      153.69823    
Loop time of 74.8289 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.786 hours/ns, 13.364 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    | 74.661     | 74.661     | 74.661     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030197   | 0.030197   | 0.030197   |   0.0 |  0.04
Output  | 6.7637e-05 | 6.7637e-05 | 6.7637e-05 |   0.0 |  0.00
Modify  | 0.12545    | 0.12545    | 0.12545    |   0.0 |  0.17
Other   |            | 0.01216    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559632 ave      559632 max      559632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559632
Ave neighs/atom = 139.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391587726395, Press = -1.2957109547658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -15361.115     -15361.115     -15505.114     -15505.114      278.57682      278.57682      59484.265      59484.265      153.69823      153.69823    
     57000  -15365.055     -15365.055     -15505.553     -15505.553      271.80295      271.80295      59482.442      59482.442      74.168974      74.168974    
Loop time of 74.4441 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.679 hours/ns, 13.433 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    | 74.276     | 74.276     | 74.276     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030068   | 0.030068   | 0.030068   |   0.0 |  0.04
Output  | 6.0584e-05 | 6.0584e-05 | 6.0584e-05 |   0.0 |  0.00
Modify  | 0.12566    | 0.12566    | 0.12566    |   0.0 |  0.17
Other   |            | 0.01208    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559702 ave      559702 max      559702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559702
Ave neighs/atom = 139.9255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.354169520022, Press = -0.00979502087503972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -15365.055     -15365.055     -15505.553     -15505.553      271.80295      271.80295      59482.442      59482.442      74.168974      74.168974    
     58000  -15363.645     -15363.645     -15501.962     -15501.962      267.58339      267.58339      59577.188      59577.188     -2541.1166     -2541.1166    
Loop time of 74.2999 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.639 hours/ns, 13.459 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    | 74.132     | 74.132     | 74.132     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030176   | 0.030176   | 0.030176   |   0.0 |  0.04
Output  | 5.5975e-05 | 5.5975e-05 | 5.5975e-05 |   0.0 |  0.00
Modify  | 0.1256     | 0.1256     | 0.1256     |   0.0 |  0.17
Other   |            | 0.01224    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8188 ave        8188 max        8188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559740 ave      559740 max      559740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559740
Ave neighs/atom = 139.935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.360714414768, Press = -1.23174190354292
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -15363.645     -15363.645     -15501.962     -15501.962      267.58339      267.58339      59577.188      59577.188     -2541.1166     -2541.1166    
     59000  -15363.124     -15363.124     -15503.918     -15503.918      272.37427      272.37427      59427.514      59427.514      2020.08        2020.08      
Loop time of 74.5084 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.697 hours/ns, 13.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.341     | 74.341     | 74.341     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03032    | 0.03032    | 0.03032    |   0.0 |  0.04
Output  | 6.2899e-05 | 6.2899e-05 | 6.2899e-05 |   0.0 |  0.00
Modify  | 0.12517    | 0.12517    | 0.12517    |   0.0 |  0.17
Other   |            | 0.01219    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8184 ave        8184 max        8184 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559554 ave      559554 max      559554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559554
Ave neighs/atom = 139.8885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.373910382563, Press = -0.500260109809845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -15363.124     -15363.124     -15503.918     -15503.918      272.37427      272.37427      59427.514      59427.514      2020.08        2020.08      
     60000  -15359.472     -15359.472     -15504.414     -15504.414      280.39924      280.39924      59518.676      59518.676     -840.84913     -840.84913    
Loop time of 74.4989 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.694 hours/ns, 13.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.331     | 74.331     | 74.331     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030256   | 0.030256   | 0.030256   |   0.0 |  0.04
Output  | 6.0143e-05 | 6.0143e-05 | 6.0143e-05 |   0.0 |  0.00
Modify  | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.17
Other   |            | 0.01221    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8195 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559710 ave      559710 max      559710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559710
Ave neighs/atom = 139.9275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393266868709, Press = -0.186177856917191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -15359.472     -15359.472     -15504.414     -15504.414      280.39924      280.39924      59518.676      59518.676     -840.84913     -840.84913    
     61000  -15360.072     -15360.072     -15503.811     -15503.811      278.07297      278.07297      59503.718      59503.718     -278.89552     -278.89552    
Loop time of 74.4519 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.681 hours/ns, 13.431 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.283     | 74.283     | 74.283     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.03034    | 0.03034    | 0.03034    |   0.0 |  0.04
Output  | 5.853e-05  | 5.853e-05  | 5.853e-05  |   0.0 |  0.00
Modify  | 0.12602    | 0.12602    | 0.12602    |   0.0 |  0.17
Other   |            | 0.01229    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559624 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390384949948, Press = -0.997632300748532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -15360.072     -15360.072     -15503.811     -15503.811      278.07297      278.07297      59503.718      59503.718     -278.89552     -278.89552    
     62000  -15365.589     -15365.589     -15505.093     -15505.093      269.88059      269.88059      59478.888      59478.888      272.78501      272.78501    
Loop time of 74.5853 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.718 hours/ns, 13.407 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.418     | 74.418     | 74.418     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030005   | 0.030005   | 0.030005   |   0.0 |  0.04
Output  | 4.809e-05  | 4.809e-05  | 4.809e-05  |   0.0 |  0.00
Modify  | 0.12521    | 0.12521    | 0.12521    |   0.0 |  0.17
Other   |            | 0.0121     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8182 ave        8182 max        8182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559668 ave      559668 max      559668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559668
Ave neighs/atom = 139.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.360213416885, Press = 0.0659881241712932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -15365.589     -15365.589     -15505.093     -15505.093      269.88059      269.88059      59478.888      59478.888      272.78501      272.78501    
     63000  -15360.065     -15360.065     -15501.592     -15501.592      273.79524      273.79524      59526.626      59526.626     -788.17361     -788.17361    
Loop time of 74.3047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.163 ns/day, 20.640 hours/ns, 13.458 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.137     | 74.137     | 74.137     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030105   | 0.030105   | 0.030105   |   0.0 |  0.04
Output  | 4.8401e-05 | 4.8401e-05 | 4.8401e-05 |   0.0 |  0.00
Modify  | 0.12524    | 0.12524    | 0.12524    |   0.0 |  0.17
Other   |            | 0.01211    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8189 ave        8189 max        8189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559624 ave      559624 max      559624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559624
Ave neighs/atom = 139.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.332659677108, Press = -1.32932815411699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -15360.065     -15360.065     -15501.592     -15501.592      273.79524      273.79524      59526.626      59526.626     -788.17361     -788.17361    
     64000  -15358.745     -15358.745     -15500.537     -15500.537      274.30613      274.30613      59445.75       59445.75       1873.8677      1873.8677    
Loop time of 74.4609 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.684 hours/ns, 13.430 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    | 74.294     | 74.294     | 74.294     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.030105   | 0.030105   | 0.030105   |   0.0 |  0.04
Output  | 4.6287e-05 | 4.6287e-05 | 4.6287e-05 |   0.0 |  0.00
Modify  | 0.12486    | 0.12486    | 0.12486    |   0.0 |  0.17
Other   |            | 0.01203    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           8193 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       559620 ave      559620 max      559620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 559620
Ave neighs/atom = 139.905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
59495.1955446249

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0