# 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 4.086000084877014*${_u_distance}
variable latticeconst_converted equal 4.086000084877014*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.08600008487701
Lattice spacing in x,y,z = 4.0860001 4.0860001 4.0860001
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.860001 40.860001 40.860001)
  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 (40.860001 40.860001 40.860001)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_AcklandTichyVitek_1987_Ag__MO_212700056563_005
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 68217.392307166 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_212700056563_005#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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -11728.581     -11728.581     -11869.776     -11869.776      273.15         273.15         68217.392      68217.392      2211.2517      2211.2517    
      1000  -11582.688     -11582.688     -11728.134     -11728.134      281.37558      281.37558      69741.99       69741.99      -537.71896     -537.71896    
Loop time of 5.23237 on 1 procs for 1000 steps with 4000 atoms

Performance: 16.513 ns/day, 1.453 hours/ns, 191.118 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    | 5.0814     | 5.0814     | 5.0814     |   0.0 | 97.11
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021509   | 0.021509   | 0.021509   |   0.0 |  0.41
Output  | 0.00011185 | 0.00011185 | 0.00011185 |   0.0 |  0.00
Modify  | 0.11892    | 0.11892    | 0.11892    |   0.0 |  2.27
Other   |            | 0.01042    |            |       |  0.20

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -11582.688     -11582.688     -11728.134     -11728.134      281.37558      281.37558      69741.99       69741.99      -537.71896     -537.71896    
      2000  -11596.449     -11596.449     -11736.661     -11736.661      271.24831      271.24831      69634.493      69634.493      147.8155       147.8155     
Loop time of 5.5849 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.470 ns/day, 1.551 hours/ns, 179.054 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    | 5.434      | 5.434      | 5.434      |   0.0 | 97.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.39
Output  | 5.2679e-05 | 5.2679e-05 | 5.2679e-05 |   0.0 |  0.00
Modify  | 0.11875    | 0.11875    | 0.11875    |   0.0 |  2.13
Other   |            | 0.01034    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315974 ave      315974 max      315974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315974
Ave neighs/atom = 78.9935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -11596.449     -11596.449     -11736.661     -11736.661      271.24831      271.24831      69634.493      69634.493      147.8155       147.8155     
      3000  -11590.612     -11590.612     -11731.565     -11731.565      272.68143      272.68143      69728.074      69728.074     -723.31493     -723.31493    
Loop time of 5.56729 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.519 ns/day, 1.546 hours/ns, 179.621 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    | 5.4172     | 5.4172     | 5.4172     |   0.0 | 97.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021701   | 0.021701   | 0.021701   |   0.0 |  0.39
Output  | 4.4815e-05 | 4.4815e-05 | 4.4815e-05 |   0.0 |  0.00
Modify  | 0.11802    | 0.11802    | 0.11802    |   0.0 |  2.12
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316052 ave      316052 max      316052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316052
Ave neighs/atom = 79.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -11590.612     -11590.612     -11731.565     -11731.565      272.68143      272.68143      69728.074      69728.074     -723.31493     -723.31493    
      4000  -11594.362     -11594.362     -11733.583     -11733.583      269.33329      269.33329      69600.806      69600.806      1234.9806      1234.9806    
Loop time of 5.57649 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.494 ns/day, 1.549 hours/ns, 179.324 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    | 5.4262     | 5.4262     | 5.4262     |   0.0 | 97.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.39
Output  | 3.718e-05  | 3.718e-05  | 3.718e-05  |   0.0 |  0.00
Modify  | 0.1184     | 0.1184     | 0.1184     |   0.0 |  2.12
Other   |            | 0.01031    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315964 ave      315964 max      315964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315964
Ave neighs/atom = 78.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -11594.362     -11594.362     -11733.583     -11733.583      269.33329      269.33329      69600.806      69600.806      1234.9806      1234.9806    
      5000  -11594.56      -11594.56      -11732.861     -11732.861      267.55262      267.55262      69689.367      69689.367     -393.24703     -393.24703    
Loop time of 5.54352 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.586 ns/day, 1.540 hours/ns, 180.391 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    | 5.3935     | 5.3935     | 5.3935     |   0.0 | 97.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021541   | 0.021541   | 0.021541   |   0.0 |  0.39
Output  | 3.2711e-05 | 3.2711e-05 | 3.2711e-05 |   0.0 |  0.00
Modify  | 0.11819    | 0.11819    | 0.11819    |   0.0 |  2.13
Other   |            | 0.01022    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316240 ave      316240 max      316240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316240
Ave neighs/atom = 79.06
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.505649804281, Press = 350.898134959268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -11594.56      -11594.56      -11732.861     -11732.861      267.55262      267.55262      69689.367      69689.367     -393.24703     -393.24703    
      6000  -11590.792     -11590.792     -11732.891     -11732.891      274.89987      274.89987      69581.939      69581.939      1676.7137      1676.7137    
Loop time of 5.57735 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.491 ns/day, 1.549 hours/ns, 179.296 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    | 5.4239     | 5.4239     | 5.4239     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021595   | 0.021595   | 0.021595   |   0.0 |  0.39
Output  | 3.8753e-05 | 3.8753e-05 | 3.8753e-05 |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  2.18
Other   |            | 0.01031    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316062 ave      316062 max      316062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316062
Ave neighs/atom = 79.0155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.733612993919, Press = 14.6534982840063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -11590.792     -11590.792     -11732.891     -11732.891      274.89987      274.89987      69581.939      69581.939      1676.7137      1676.7137    
      7000  -11593.51      -11593.51      -11733.76      -11733.76       271.32243      271.32243      69600.75       69600.75       1128.5728      1128.5728    
Loop time of 5.55563 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.552 ns/day, 1.543 hours/ns, 179.998 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4023     | 5.4023     | 5.4023     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021571   | 0.021571   | 0.021571   |   0.0 |  0.39
Output  | 6.0464e-05 | 6.0464e-05 | 6.0464e-05 |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  2.18
Other   |            | 0.01031    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316232 ave      316232 max      316232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316232
Ave neighs/atom = 79.058
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.063465338428, Press = -0.510886227174786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -11593.51      -11593.51      -11733.76      -11733.76       271.32243      271.32243      69600.75       69600.75       1128.5728      1128.5728    
      8000  -11590.017     -11590.017     -11732.558     -11732.558      275.75387      275.75387      69680.472      69680.472     -112.30479     -112.30479    
Loop time of 5.56405 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.528 ns/day, 1.546 hours/ns, 179.725 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    | 5.4109     | 5.4109     | 5.4109     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021564   | 0.021564   | 0.021564   |   0.0 |  0.39
Output  | 3.1359e-05 | 3.1359e-05 | 3.1359e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  2.18
Other   |            | 0.01027    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316210 ave      316210 max      316210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316210
Ave neighs/atom = 79.0525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.182652679762, Press = 17.2296800406631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -11590.017     -11590.017     -11732.558     -11732.558      275.75387      275.75387      69680.472      69680.472     -112.30479     -112.30479    
      9000  -11595.413     -11595.413     -11735.464     -11735.464      270.93803      270.93803      69621.315      69621.315      508.33526      508.33526    
Loop time of 5.55675 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.549 ns/day, 1.544 hours/ns, 179.961 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4033     | 5.4033     | 5.4033     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.39
Output  | 3.1319e-05 | 3.1319e-05 | 3.1319e-05 |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  2.19
Other   |            | 0.01031    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316042 ave      316042 max      316042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316042
Ave neighs/atom = 79.0105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.062486527094, Press = -0.306866511950383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -11595.413     -11595.413     -11735.464     -11735.464      270.93803      270.93803      69621.315      69621.315      508.33526      508.33526    
     10000  -11591.408     -11591.408     -11733.336     -11733.336      274.57011      274.57011      69634.432      69634.432      667.17907      667.17907    
Loop time of 5.5592 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.542 ns/day, 1.544 hours/ns, 179.882 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    | 5.4061     | 5.4061     | 5.4061     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021551   | 0.021551   | 0.021551   |   0.0 |  0.39
Output  | 3.189e-05  | 3.189e-05  | 3.189e-05  |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  2.18
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316026 ave      316026 max      316026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316026
Ave neighs/atom = 79.0065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.648772835509, Press = -0.0454555736700344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -11591.408     -11591.408     -11733.336     -11733.336      274.57011      274.57011      69634.432      69634.432      667.17907      667.17907    
     11000  -11593.881     -11593.881     -11733.958     -11733.958      270.98831      270.98831      69659.806      69659.806      90.814892      90.814892    
Loop time of 5.58956 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.457 ns/day, 1.553 hours/ns, 178.905 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    | 5.4361     | 5.4361     | 5.4361     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021534   | 0.021534   | 0.021534   |   0.0 |  0.39
Output  | 2.9765e-05 | 2.9765e-05 | 2.9765e-05 |   0.0 |  0.00
Modify  | 0.12157    | 0.12157    | 0.12157    |   0.0 |  2.17
Other   |            | 0.01034    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316138 ave      316138 max      316138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316138
Ave neighs/atom = 79.0345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.754484049775, Press = 0.205579861200587
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -11593.881     -11593.881     -11733.958     -11733.958      270.98831      270.98831      69659.806      69659.806      90.814892      90.814892    
     12000  -11591.916     -11591.916     -11735.459     -11735.459      277.69324      277.69324      69681.403      69681.403     -566.74523     -566.74523    
Loop time of 5.57646 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.494 ns/day, 1.549 hours/ns, 179.325 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    | 5.423      | 5.423      | 5.423      |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021594   | 0.021594   | 0.021594   |   0.0 |  0.39
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  2.18
Other   |            | 0.01035    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316204 ave      316204 max      316204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316204
Ave neighs/atom = 79.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856214259788, Press = -0.147855596281888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -11591.916     -11591.916     -11735.459     -11735.459      277.69324      277.69324      69681.403      69681.403     -566.74523     -566.74523    
     13000  -11600.464     -11600.464     -11739.757     -11739.757      269.4728       269.4728       69574.715      69574.715      687.55194      687.55194    
Loop time of 5.54458 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.583 ns/day, 1.540 hours/ns, 180.356 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    | 5.3912     | 5.3912     | 5.3912     |   0.0 | 97.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021673   | 0.021673   | 0.021673   |   0.0 |  0.39
Output  | 3.19e-05   | 3.19e-05   | 3.19e-05   |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  2.19
Other   |            | 0.01029    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315968 ave      315968 max      315968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315968
Ave neighs/atom = 78.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.640813981041, Press = 2.28528313008327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -11600.464     -11600.464     -11739.757     -11739.757      269.4728       269.4728       69574.715      69574.715      687.55194      687.55194    
     14000  -11589.503     -11589.503     -11732.551     -11732.551      276.73637      276.73637      69640.823      69640.823      603.39126      603.39126    
Loop time of 5.58582 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.468 ns/day, 1.552 hours/ns, 179.025 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    | 5.4322     | 5.4322     | 5.4322     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021713   | 0.021713   | 0.021713   |   0.0 |  0.39
Output  | 3.1599e-05 | 3.1599e-05 | 3.1599e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  2.18
Other   |            | 0.01029    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316212 ave      316212 max      316212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316212
Ave neighs/atom = 79.053
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.58619391362, Press = 6.43151858378685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -11589.503     -11589.503     -11732.551     -11732.551      276.73637      276.73637      69640.823      69640.823      603.39126      603.39126    
     15000  -11593.164     -11593.164     -11733.803     -11733.803      272.07515      272.07515      69724.089      69724.089     -1139.6812     -1139.6812    
Loop time of 5.56564 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.524 ns/day, 1.546 hours/ns, 179.674 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    | 5.412      | 5.412      | 5.412      |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021581   | 0.021581   | 0.021581   |   0.0 |  0.39
Output  | 2.8454e-05 | 2.8454e-05 | 2.8454e-05 |   0.0 |  0.00
Modify  | 0.12174    | 0.12174    | 0.12174    |   0.0 |  2.19
Other   |            | 0.01031    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316062 ave      316062 max      316062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316062
Ave neighs/atom = 79.0155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.673214721763, Press = -1.09187145276558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -11593.164     -11593.164     -11733.803     -11733.803      272.07515      272.07515      69724.089      69724.089     -1139.6812     -1139.6812    
     16000  -11596.494     -11596.494     -11735.868     -11735.868      269.62931      269.62931      69656.933      69656.933     -201.00304     -201.00304    
Loop time of 5.57634 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.494 ns/day, 1.549 hours/ns, 179.329 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    | 5.4227     | 5.4227     | 5.4227     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021625   | 0.021625   | 0.021625   |   0.0 |  0.39
Output  | 3.1659e-05 | 3.1659e-05 | 3.1659e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  2.18
Other   |            | 0.01033    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315906 ave      315906 max      315906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315906
Ave neighs/atom = 78.9765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.701965862855, Press = 2.02536904015106
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -11596.494     -11596.494     -11735.868     -11735.868      269.62931      269.62931      69656.933      69656.933     -201.00304     -201.00304    
     17000  -11590.758     -11590.758     -11731.425     -11731.425      272.12962      272.12962      69676.583      69676.583      114.24713      114.24713    
Loop time of 5.59287 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.448 ns/day, 1.554 hours/ns, 178.799 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    | 5.4391     | 5.4391     | 5.4391     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021666   | 0.021666   | 0.021666   |   0.0 |  0.39
Output  | 3.2712e-05 | 3.2712e-05 | 3.2712e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  2.18
Other   |            | 0.01032    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315982 ave      315982 max      315982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315982
Ave neighs/atom = 78.9955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.68187687415, Press = 1.23585630803151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -11590.758     -11590.758     -11731.425     -11731.425      272.12962      272.12962      69676.583      69676.583      114.24713      114.24713    
     18000  -11595.547     -11595.547     -11737.871     -11737.871      275.3352       275.3352       69537.858      69537.858      1680.9146      1680.9146    
Loop time of 5.56267 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.532 ns/day, 1.545 hours/ns, 179.770 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    | 5.4093     | 5.4093     | 5.4093     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021655   | 0.021655   | 0.021655   |   0.0 |  0.39
Output  | 3.0568e-05 | 3.0568e-05 | 3.0568e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  2.18
Other   |            | 0.01029    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316112 ave      316112 max      316112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316112
Ave neighs/atom = 79.028
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.668872876754, Press = 2.54227968372306
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -11595.547     -11595.547     -11737.871     -11737.871      275.3352       275.3352       69537.858      69537.858      1680.9146      1680.9146    
     19000  -11593.355     -11593.355     -11733.418     -11733.418      270.96009      270.96009      69687.288      69687.288     -399.26756     -399.26756    
Loop time of 5.58845 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.460 ns/day, 1.552 hours/ns, 178.940 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    | 5.435      | 5.435      | 5.435      |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021635   | 0.021635   | 0.021635   |   0.0 |  0.39
Output  | 2.9405e-05 | 2.9405e-05 | 2.9405e-05 |   0.0 |  0.00
Modify  | 0.12152    | 0.12152    | 0.12152    |   0.0 |  2.17
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316156 ave      316156 max      316156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316156
Ave neighs/atom = 79.039
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.705865597877, Press = 1.5804678870378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -11593.355     -11593.355     -11733.418     -11733.418      270.96009      270.96009      69687.288      69687.288     -399.26756     -399.26756    
     20000  -11587.449     -11587.449     -11728.813     -11728.813      273.47788      273.47788      69626.175      69626.175      1494.9313      1494.9313    
Loop time of 5.55582 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.551 ns/day, 1.543 hours/ns, 179.991 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    | 5.4025     | 5.4025     | 5.4025     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.39
Output  | 3.194e-05  | 3.194e-05  | 3.194e-05  |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  2.19
Other   |            | 0.01025    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315914 ave      315914 max      315914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315914
Ave neighs/atom = 78.9785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.771548436113, Press = 1.96803092158798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -11587.449     -11587.449     -11728.813     -11728.813      273.47788      273.47788      69626.175      69626.175      1494.9313      1494.9313    
     21000  -11593.151     -11593.151     -11733.437     -11733.437      271.39248      271.39248      69671.986      69671.986     -167.641       -167.641      
Loop time of 5.56528 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.525 ns/day, 1.546 hours/ns, 179.685 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    | 5.4121     | 5.4121     | 5.4121     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021707   | 0.021707   | 0.021707   |   0.0 |  0.39
Output  | 3.2331e-05 | 3.2331e-05 | 3.2331e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  2.18
Other   |            | 0.01026    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316242 ave      316242 max      316242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316242
Ave neighs/atom = 79.0605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.92646294925, Press = 0.646773580495792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -11593.151     -11593.151     -11733.437     -11733.437      271.39248      271.39248      69671.986      69671.986     -167.641       -167.641      
     22000  -11589.086     -11589.086     -11732.386     -11732.386      277.22298      277.22298      69660.736      69660.736      342.72319      342.72319    
Loop time of 5.58608 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.467 ns/day, 1.552 hours/ns, 179.016 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    | 5.4329     | 5.4329     | 5.4329     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021603   | 0.021603   | 0.021603   |   0.0 |  0.39
Output  | 3.0798e-05 | 3.0798e-05 | 3.0798e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  2.17
Other   |            | 0.01026    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315848 ave      315848 max      315848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315848
Ave neighs/atom = 78.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.97888023487, Press = 3.58324802378447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -11589.086     -11589.086     -11732.386     -11732.386      277.22298      277.22298      69660.736      69660.736      342.72319      342.72319    
     23000  -11590.654     -11590.654     -11733.653     -11733.653      276.64128      276.64128      69635.49       69635.49       593.18012      593.18012    
Loop time of 5.57502 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.498 ns/day, 1.549 hours/ns, 179.372 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    | 5.4215     | 5.4215     | 5.4215     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021691   | 0.021691   | 0.021691   |   0.0 |  0.39
Output  | 4.0476e-05 | 4.0476e-05 | 4.0476e-05 |   0.0 |  0.00
Modify  | 0.12147    | 0.12147    | 0.12147    |   0.0 |  2.18
Other   |            | 0.0103     |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316068 ave      316068 max      316068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316068
Ave neighs/atom = 79.017
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.990056164294, Press = 1.30726370837075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -11590.654     -11590.654     -11733.653     -11733.653      276.64128      276.64128      69635.49       69635.49       593.18012      593.18012    
     24000  -11591.894     -11591.894     -11732.81      -11732.81       272.61099      272.61099      69707.154      69707.154     -632.13141     -632.13141    
Loop time of 5.60736 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.408 ns/day, 1.558 hours/ns, 178.337 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    | 5.4547     | 5.4547     | 5.4547     |   0.0 | 97.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021581   | 0.021581   | 0.021581   |   0.0 |  0.38
Output  | 7.8418e-05 | 7.8418e-05 | 7.8418e-05 |   0.0 |  0.00
Modify  | 0.12083    | 0.12083    | 0.12083    |   0.0 |  2.15
Other   |            | 0.01021    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316116 ave      316116 max      316116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316116
Ave neighs/atom = 79.029
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.994444711753, Press = 0.232728264695397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -11591.894     -11591.894     -11732.81      -11732.81       272.61099      272.61099      69707.154      69707.154     -632.13141     -632.13141    
     25000  -11590.892     -11590.892     -11735.362     -11735.362      279.48766      279.48766      69707.612      69707.612     -992.19038     -992.19038    
Loop time of 5.58611 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.467 ns/day, 1.552 hours/ns, 179.015 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 5.4338     | 5.4338     | 5.4338     |   0.0 | 97.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021548   | 0.021548   | 0.021548   |   0.0 |  0.39
Output  | 3.1219e-05 | 3.1219e-05 | 3.1219e-05 |   0.0 |  0.00
Modify  | 0.12058    | 0.12058    | 0.12058    |   0.0 |  2.16
Other   |            | 0.01018    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316040 ave      316040 max      316040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316040
Ave neighs/atom = 79.01
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.118539585062, Press = -0.337388068490974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -11590.892     -11590.892     -11735.362     -11735.362      279.48766      279.48766      69707.612      69707.612     -992.19038     -992.19038    
     26000  -11594.058     -11594.058     -11734.306     -11734.306      271.31828      271.31828      69660.33       69660.33       1.6221484      1.6221484    
Loop time of 5.55324 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.558 ns/day, 1.543 hours/ns, 180.075 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    | 5.4008     | 5.4008     | 5.4008     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021571   | 0.021571   | 0.021571   |   0.0 |  0.39
Output  | 3.0898e-05 | 3.0898e-05 | 3.0898e-05 |   0.0 |  0.00
Modify  | 0.12071    | 0.12071    | 0.12071    |   0.0 |  2.17
Other   |            | 0.01018    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315920 ave      315920 max      315920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315920
Ave neighs/atom = 78.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.130563527784, Press = 1.03282195695323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -11594.058     -11594.058     -11734.306     -11734.306      271.31828      271.31828      69660.33       69660.33       1.6221484      1.6221484    
     27000  -11593.153     -11593.153     -11734.563     -11734.563      273.56789      273.56789      69701.968      69701.968     -822.77577     -822.77577    
Loop time of 5.58993 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.456 ns/day, 1.553 hours/ns, 178.893 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    | 5.4372     | 5.4372     | 5.4372     |   0.0 | 97.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021585   | 0.021585   | 0.021585   |   0.0 |  0.39
Output  | 3.2412e-05 | 3.2412e-05 | 3.2412e-05 |   0.0 |  0.00
Modify  | 0.12088    | 0.12088    | 0.12088    |   0.0 |  2.16
Other   |            | 0.0102     |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315946 ave      315946 max      315946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315946
Ave neighs/atom = 78.9865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.151154124921, Press = 0.821052562469004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -11593.153     -11593.153     -11734.563     -11734.563      273.56789      273.56789      69701.968      69701.968     -822.77577     -822.77577    
     28000  -11596.936     -11596.936     -11735.301     -11735.301      267.67714      267.67714      69787.158      69787.158     -2541.4734     -2541.4734    
Loop time of 5.55605 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.551 ns/day, 1.543 hours/ns, 179.984 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    | 5.4028     | 5.4028     | 5.4028     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021588   | 0.021588   | 0.021588   |   0.0 |  0.39
Output  | 3.2801e-05 | 3.2801e-05 | 3.2801e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  2.18
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315924 ave      315924 max      315924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315924
Ave neighs/atom = 78.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.082156534954, Press = 0.765301017501329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -11596.936     -11596.936     -11735.301     -11735.301      267.67714      267.67714      69787.158      69787.158     -2541.4734     -2541.4734    
     29000  -11593.525     -11593.525     -11735.679     -11735.679      275.00549      275.00549      69620.633      69620.633      518.07904      518.07904    
Loop time of 5.57426 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.500 ns/day, 1.548 hours/ns, 179.396 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    | 5.4214     | 5.4214     | 5.4214     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021494   | 0.021494   | 0.021494   |   0.0 |  0.39
Output  | 2.9816e-05 | 2.9816e-05 | 2.9816e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  2.17
Other   |            | 0.01023    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315610 ave      315610 max      315610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315610
Ave neighs/atom = 78.9025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.081107593398, Press = 0.643281413097501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -11593.525     -11593.525     -11735.679     -11735.679      275.00549      275.00549      69620.633      69620.633      518.07904      518.07904    
     30000  -11593.132     -11593.132     -11732.965     -11732.965      270.51484      270.51484      69679.939      69679.939     -264.40758     -264.40758    
Loop time of 5.55807 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.545 ns/day, 1.544 hours/ns, 179.919 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    | 5.4047     | 5.4047     | 5.4047     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021607   | 0.021607   | 0.021607   |   0.0 |  0.39
Output  | 3.1429e-05 | 3.1429e-05 | 3.1429e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  2.19
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315964 ave      315964 max      315964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315964
Ave neighs/atom = 78.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.026481144283, Press = -0.272456757118468
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -11593.132     -11593.132     -11732.965     -11732.965      270.51484      270.51484      69679.939      69679.939     -264.40758     -264.40758    
     31000  -11593.898     -11593.898     -11735.456     -11735.456      273.85396      273.85396      69740.721      69740.721     -1675.6112     -1675.6112    
Loop time of 5.59955 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.430 ns/day, 1.555 hours/ns, 178.586 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    | 5.4464     | 5.4464     | 5.4464     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021601   | 0.021601   | 0.021601   |   0.0 |  0.39
Output  | 3.0046e-05 | 3.0046e-05 | 3.0046e-05 |   0.0 |  0.00
Modify  | 0.12124    | 0.12124    | 0.12124    |   0.0 |  2.17
Other   |            | 0.0103     |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315980 ave      315980 max      315980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315980
Ave neighs/atom = 78.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.070870008487, Press = 0.771255881858017
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -11593.898     -11593.898     -11735.456     -11735.456      273.85396      273.85396      69740.721      69740.721     -1675.6112     -1675.6112    
     32000  -11592.629     -11592.629     -11733.78      -11733.78       273.06737      273.06737      69619.577      69619.577      685.80607      685.80607    
Loop time of 5.54758 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.574 ns/day, 1.541 hours/ns, 180.259 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    | 5.3945     | 5.3945     | 5.3945     |   0.0 | 97.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021557   | 0.021557   | 0.021557   |   0.0 |  0.39
Output  | 3.3493e-05 | 3.3493e-05 | 3.3493e-05 |   0.0 |  0.00
Modify  | 0.12123    | 0.12123    | 0.12123    |   0.0 |  2.19
Other   |            | 0.01027    |            |       |  0.19

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315790 ave      315790 max      315790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315790
Ave neighs/atom = 78.9475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.112000478618, Press = 1.93030560064154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -11592.629     -11592.629     -11733.78      -11733.78       273.06737      273.06737      69619.577      69619.577      685.80607      685.80607    
     33000  -11592.931     -11592.931     -11735.441     -11735.441      275.69557      275.69557      69722.719      69722.719     -1329.9627     -1329.9627    
Loop time of 5.5904 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.455 ns/day, 1.553 hours/ns, 178.878 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    | 5.4372     | 5.4372     | 5.4372     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021576   | 0.021576   | 0.021576   |   0.0 |  0.39
Output  | 3.8593e-05 | 3.8593e-05 | 3.8593e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  2.17
Other   |            | 0.01029    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316110 ave      316110 max      316110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316110
Ave neighs/atom = 79.0275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.048564911654, Press = -0.315756466801381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -11592.931     -11592.931     -11735.441     -11735.441      275.69557      275.69557      69722.719      69722.719     -1329.9627     -1329.9627    
     34000  -11594.239     -11594.239     -11732.366     -11732.366      267.21631      267.21631      69652.007      69652.007      386.74007      386.74007    
Loop time of 5.5634 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.530 ns/day, 1.545 hours/ns, 179.746 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    | 5.4105     | 5.4105     | 5.4105     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021491   | 0.021491   | 0.021491   |   0.0 |  0.39
Output  | 2.9315e-05 | 2.9315e-05 | 2.9315e-05 |   0.0 |  0.00
Modify  | 0.12108    | 0.12108    | 0.12108    |   0.0 |  2.18
Other   |            | 0.01025    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315892 ave      315892 max      315892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315892
Ave neighs/atom = 78.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.07297746814, Press = 0.280687077212878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -11594.239     -11594.239     -11732.366     -11732.366      267.21631      267.21631      69652.007      69652.007      386.74007      386.74007    
     35000  -11587.014     -11587.014     -11730.772     -11730.772      278.10883      278.10883      69660.404      69660.404      571.94279      571.94279    
Loop time of 5.57495 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.498 ns/day, 1.549 hours/ns, 179.374 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    | 5.422      | 5.422      | 5.422      |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021504   | 0.021504   | 0.021504   |   0.0 |  0.39
Output  | 3.3042e-05 | 3.3042e-05 | 3.3042e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  2.17
Other   |            | 0.01023    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316214 ave      316214 max      316214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316214
Ave neighs/atom = 79.0535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.118504546522, Press = 0.843231331866759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -11587.014     -11587.014     -11730.772     -11730.772      278.10883      278.10883      69660.404      69660.404      571.94279      571.94279    
     36000  -11593.841     -11593.841     -11734.267     -11734.267      271.66343      271.66343      69619.222      69619.222      686.67756      686.67756    
Loop time of 5.57795 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.490 ns/day, 1.549 hours/ns, 179.277 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    | 5.4249     | 5.4249     | 5.4249     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021768   | 0.021768   | 0.021768   |   0.0 |  0.39
Output  | 3.2271e-05 | 3.2271e-05 | 3.2271e-05 |   0.0 |  0.00
Modify  | 0.12107    | 0.12107    | 0.12107    |   0.0 |  2.17
Other   |            | 0.01022    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316212 ave      316212 max      316212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316212
Ave neighs/atom = 79.053
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.097710493041, Press = 1.12213427649081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -11593.841     -11593.841     -11734.267     -11734.267      271.66343      271.66343      69619.222      69619.222      686.67756      686.67756    
     37000  -11591.154     -11591.154     -11729.915     -11729.915      268.44111      268.44111      69698.462      69698.462     -119.85582     -119.85582    
Loop time of 5.58941 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.458 ns/day, 1.553 hours/ns, 178.910 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    | 5.4363     | 5.4363     | 5.4363     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021604   | 0.021604   | 0.021604   |   0.0 |  0.39
Output  | 3.1178e-05 | 3.1178e-05 | 3.1178e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  2.17
Other   |            | 0.01025    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316108 ave      316108 max      316108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316108
Ave neighs/atom = 79.027
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.100383365218, Press = -0.697139437877462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -11591.154     -11591.154     -11729.915     -11729.915      268.44111      268.44111      69698.462      69698.462     -119.85582     -119.85582    
     38000  -11592.821     -11592.821     -11735.334     -11735.334      275.70094      275.70094      69641.17       69641.17       183.68937      183.68937    
Loop time of 5.57553 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.496 ns/day, 1.549 hours/ns, 179.355 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    | 5.4223     | 5.4223     | 5.4223     |   0.0 | 97.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02165    | 0.02165    | 0.02165    |   0.0 |  0.39
Output  | 3.0678e-05 | 3.0678e-05 | 3.0678e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  2.18
Other   |            | 0.01028    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315984 ave      315984 max      315984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315984
Ave neighs/atom = 78.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.116700821473, Press = 1.44973964147329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -11592.821     -11592.821     -11735.334     -11735.334      275.70094      275.70094      69641.17       69641.17       183.68937      183.68937    
     39000  -11590.164     -11590.164     -11731.154     -11731.154      272.75458      272.75458      69807.436      69807.436     -2310.723      -2310.723     
Loop time of 5.58452 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.471 ns/day, 1.551 hours/ns, 179.066 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    | 5.4313     | 5.4313     | 5.4313     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021591   | 0.021591   | 0.021591   |   0.0 |  0.39
Output  | 3.2201e-05 | 3.2201e-05 | 3.2201e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  2.17
Other   |            | 0.0103     |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316052 ave      316052 max      316052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 316052
Ave neighs/atom = 79.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.159948590314, Press = 0.602886602432051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -11590.164     -11590.164     -11731.154     -11731.154      272.75458      272.75458      69807.436      69807.436     -2310.723      -2310.723     
     40000  -11592.058     -11592.058     -11733.6       -11733.6        273.82341      273.82341      69622.768      69622.768      751.51929      751.51929    
Loop time of 5.59431 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.444 ns/day, 1.554 hours/ns, 178.753 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    | 5.441      | 5.441      | 5.441      |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.39
Output  | 3.2751e-05 | 3.2751e-05 | 3.2751e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  2.17
Other   |            | 0.01025    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       315820 ave      315820 max      315820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 315820
Ave neighs/atom = 78.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.141357917561, Press = 1.15857142116923
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.0043077
  ghost atom cutoff = 7.0043077
  binsize = 3.5021538, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.0043076614
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -11592.058     -11592.058     -11733.6       -11733.6        273.82341      273.82341      69622.768      69622.768      751.51929      751.51929    
     41000  -11597.675     -11597.675     -11735.042     -11735.042      265.74544      265.74544      69576.964      69576.964      1244.0918      1244.0918    
Loop time of 5.59534 on 1 procs for 1000 steps with 4000 atoms

Performance: 15.441 ns/day, 1.554 hours/ns, 178.720 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    | 5.4422     | 5.4422     | 5.4422     |   0.0 | 97.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021641   | 0.021641   | 0.021641   |   0.0 |  0.39
Output  | 3.0006e-05 | 3.0006e-05 | 3.0006e-05 |   0.0 |  0.00
Modify  | 0.12119    | 0.12119    | 0.12119    |   0.0 |  2.17
Other   |            | 0.01026    |            |       |  0.18

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       316160 ave      316160 max      316160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0