# 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.195095829665661*${_u_distance}
variable latticeconst_converted equal 4.195095829665661*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  4.19509582966566
Lattice spacing in x,y,z = 4.1950958 4.1950958 4.1950958
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (41.950958 41.950958 41.950958)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (41.950958 41.950958 41.950958)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Na

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

kim interactions Na
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimKoLee_2020_Na__MO_321355778754_002
pair_coeff * * Na
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 22.98977

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

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

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

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

Performance: 1.072 ns/day, 22.396 hours/ns, 12.403 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.978     | 79.978     | 79.978     |   0.0 | 99.20
Neigh   | 0.16538    | 0.16538    | 0.16538    |   0.0 |  0.21
Comm    | 0.0798     | 0.0798     | 0.0798     |   0.0 |  0.10
Output  | 0.00024419 | 0.00024419 | 0.00024419 |   0.0 |  0.00
Modify  | 0.3474     | 0.3474     | 0.3474     |   0.0 |  0.43
Other   |            | 0.05416    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2822 ave        2822 max        2822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62800 ave       62800 max       62800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.079 ns/day, 22.236 hours/ns, 12.492 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.417     | 79.417     | 79.417     |   0.0 | 99.21
Neigh   | 0.16618    | 0.16618    | 0.16618    |   0.0 |  0.21
Comm    | 0.077852   | 0.077852   | 0.077852   |   0.0 |  0.10
Output  | 0.00018743 | 0.00018743 | 0.00018743 |   0.0 |  0.00
Modify  | 0.33528    | 0.33528    | 0.33528    |   0.0 |  0.42
Other   |            | 0.05318    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2868 ave        2868 max        2868 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        63080 ave       63080 max       63080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.079 ns/day, 22.252 hours/ns, 12.483 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.476     | 79.476     | 79.476     |   0.0 | 99.21
Neigh   | 0.16577    | 0.16577    | 0.16577    |   0.0 |  0.21
Comm    | 0.078191   | 0.078191   | 0.078191   |   0.0 |  0.10
Output  | 0.00020495 | 0.00020495 | 0.00020495 |   0.0 |  0.00
Modify  | 0.33527    | 0.33527    | 0.33527    |   0.0 |  0.42
Other   |            | 0.05338    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2887 ave        2887 max        2887 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62942 ave       62942 max       62942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.078 ns/day, 22.254 hours/ns, 12.482 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.481     | 79.481     | 79.481     |   0.0 | 99.21
Neigh   | 0.16604    | 0.16604    | 0.16604    |   0.0 |  0.21
Comm    | 0.078271   | 0.078271   | 0.078271   |   0.0 |  0.10
Output  | 0.00020509 | 0.00020509 | 0.00020509 |   0.0 |  0.00
Modify  | 0.33568    | 0.33568    | 0.33568    |   0.0 |  0.42
Other   |            | 0.0532     |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2887 ave        2887 max        2887 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62724 ave       62724 max       62724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.078 ns/day, 22.263 hours/ns, 12.477 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.51      | 79.51      | 79.51      |   0.0 | 99.21
Neigh   | 0.16618    | 0.16618    | 0.16618    |   0.0 |  0.21
Comm    | 0.078115   | 0.078115   | 0.078115   |   0.0 |  0.10
Output  | 0.00019465 | 0.00019465 | 0.00019465 |   0.0 |  0.00
Modify  | 0.33764    | 0.33764    | 0.33764    |   0.0 |  0.42
Other   |            | 0.05301    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2867 ave        2867 max        2867 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62970 ave       62970 max       62970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62970
Ave neighs/atom = 31.485
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 276.683309750669, Press = -5.72509100080586
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -2076.7824     -2076.7824     -2147.3697     -2147.3697      273.18013      273.18013      77113.272      77113.272      6.7242168      6.7242168    
      6000  -2078.6944     -2078.6944     -2151.1608     -2151.1608      280.45221      280.45221      76843.264      76843.264      8.2382073      8.2382073    
Loop time of 90.2242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.958 ns/day, 25.062 hours/ns, 11.083 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    | 89.489     | 89.489     | 89.489     |   0.0 | 99.19
Neigh   | 0.17757    | 0.17757    | 0.17757    |   0.0 |  0.20
Comm    | 0.084848   | 0.084848   | 0.084848   |   0.0 |  0.09
Output  | 0.00016391 | 0.00016391 | 0.00016391 |   0.0 |  0.00
Modify  | 0.41382    | 0.41382    | 0.41382    |   0.0 |  0.46
Other   |            | 0.05884    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2904 ave        2904 max        2904 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62650 ave       62650 max       62650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62650
Ave neighs/atom = 31.325
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.948721571309, Press = -15.1902492882053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -2078.6944     -2078.6944     -2151.1608     -2151.1608      280.45221      280.45221      76843.264      76843.264      8.2382073      8.2382073    
      7000  -2079.383      -2079.383      -2149.1945     -2149.1945      270.17754      270.17754      77484.938      77484.938     -568.95562     -568.95562    
Loop time of 94.2626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.917 ns/day, 26.184 hours/ns, 10.609 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    | 93.48      | 93.48      | 93.48      |   0.0 | 99.17
Neigh   | 0.19377    | 0.19377    | 0.19377    |   0.0 |  0.21
Comm    | 0.088673   | 0.088673   | 0.088673   |   0.0 |  0.09
Output  | 0.00022579 | 0.00022579 | 0.00022579 |   0.0 |  0.00
Modify  | 0.4401     | 0.4401     | 0.4401     |   0.0 |  0.47
Other   |            | 0.06005    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2856 ave        2856 max        2856 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62004 ave       62004 max       62004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62004
Ave neighs/atom = 31.002
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.218373409498, Press = 6.47092054155548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -2079.383      -2079.383      -2149.1945     -2149.1945      270.17754      270.17754      77484.938      77484.938     -568.95562     -568.95562    
      8000  -2079.8946     -2079.8946     -2149.5246     -2149.5246      269.47539      269.47539      76746.768      76746.768      314.64084      314.64084    
Loop time of 93.7387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.922 ns/day, 26.039 hours/ns, 10.668 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.955     | 92.955     | 92.955     |   0.0 | 99.16
Neigh   | 0.19509    | 0.19509    | 0.19509    |   0.0 |  0.21
Comm    | 0.088187   | 0.088187   | 0.088187   |   0.0 |  0.09
Output  | 0.00025473 | 0.00025473 | 0.00025473 |   0.0 |  0.00
Modify  | 0.44001    | 0.44001    | 0.44001    |   0.0 |  0.47
Other   |            | 0.05979    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2885 ave        2885 max        2885 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62870 ave       62870 max       62870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62870
Ave neighs/atom = 31.435
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.892526960315, Press = -2.42948085460505
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -2079.8946     -2079.8946     -2149.5246     -2149.5246      269.47539      269.47539      76746.768      76746.768      314.64084      314.64084    
      9000  -2076.3648     -2076.3648     -2147.3904     -2147.3904      274.87619      274.87619      77095.503      77095.503      20.639843      20.639843    
Loop time of 93.6716 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.922 ns/day, 26.020 hours/ns, 10.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.903     | 92.903     | 92.903     |   0.0 | 99.18
Neigh   | 0.17857    | 0.17857    | 0.17857    |   0.0 |  0.19
Comm    | 0.088735   | 0.088735   | 0.088735   |   0.0 |  0.09
Output  | 0.00021309 | 0.00021309 | 0.00021309 |   0.0 |  0.00
Modify  | 0.44174    | 0.44174    | 0.44174    |   0.0 |  0.47
Other   |            | 0.05971    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2874 ave        2874 max        2874 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62686 ave       62686 max       62686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62686
Ave neighs/atom = 31.343
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383249716682, Press = -1.63303691114646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -2076.3648     -2076.3648     -2147.3904     -2147.3904      274.87619      274.87619      77095.503      77095.503      20.639843      20.639843    
     10000  -2080.0338     -2080.0338     -2149.3966     -2149.3966      268.44125      268.44125      77039.279      77039.279     -75.320633     -75.320633    
Loop time of 93.4268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.925 ns/day, 25.952 hours/ns, 10.704 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    | 92.661     | 92.661     | 92.661     |   0.0 | 99.18
Neigh   | 0.17961    | 0.17961    | 0.17961    |   0.0 |  0.19
Comm    | 0.088596   | 0.088596   | 0.088596   |   0.0 |  0.09
Output  | 0.00024108 | 0.00024108 | 0.00024108 |   0.0 |  0.00
Modify  | 0.43665    | 0.43665    | 0.43665    |   0.0 |  0.47
Other   |            | 0.06026    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2879 ave        2879 max        2879 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62646 ave       62646 max       62646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62646
Ave neighs/atom = 31.323
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416415847932, Press = -0.680677338318861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -2080.0338     -2080.0338     -2149.3966     -2149.3966      268.44125      268.44125      77039.279      77039.279     -75.320633     -75.320633    
     11000  -2076.9222     -2076.9222     -2150.019      -2150.019       282.8922       282.8922       76999.812      76999.812      158.8649       158.8649     
Loop time of 93.5487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.924 ns/day, 25.986 hours/ns, 10.690 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    | 92.777     | 92.777     | 92.777     |   0.0 | 99.17
Neigh   | 0.17893    | 0.17893    | 0.17893    |   0.0 |  0.19
Comm    | 0.089368   | 0.089368   | 0.089368   |   0.0 |  0.10
Output  | 0.00017065 | 0.00017065 | 0.00017065 |   0.0 |  0.00
Modify  | 0.44351    | 0.44351    | 0.44351    |   0.0 |  0.47
Other   |            | 0.06012    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2859 ave        2859 max        2859 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62788 ave       62788 max       62788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62788
Ave neighs/atom = 31.394
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.149770092707, Press = 0.237647404746801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -2076.9222     -2076.9222     -2150.019      -2150.019       282.8922       282.8922       76999.812      76999.812      158.8649       158.8649     
     12000  -2076.8589     -2076.8589     -2148.7796     -2148.7796      278.34073      278.34073      77023.937      77023.937      4.7264193      4.7264193    
Loop time of 93.5717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.923 ns/day, 25.992 hours/ns, 10.687 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    | 92.784     | 92.784     | 92.784     |   0.0 | 99.16
Neigh   | 0.19462    | 0.19462    | 0.19462    |   0.0 |  0.21
Comm    | 0.089992   | 0.089992   | 0.089992   |   0.0 |  0.10
Output  | 0.0002299  | 0.0002299  | 0.0002299  |   0.0 |  0.00
Modify  | 0.44296    | 0.44296    | 0.44296    |   0.0 |  0.47
Other   |            | 0.05981    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2890 ave        2890 max        2890 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62458 ave       62458 max       62458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62458
Ave neighs/atom = 31.229
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.303843213642, Press = -4.21238304519091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -2076.8589     -2076.8589     -2148.7796     -2148.7796      278.34073      278.34073      77023.937      77023.937      4.7264193      4.7264193    
     13000  -2081.5694     -2081.5694     -2151.3119     -2151.3119      269.91095      269.91095      77008.232      77008.232     -169.74032     -169.74032    
Loop time of 94.0645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.919 ns/day, 26.129 hours/ns, 10.631 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    | 93.294     | 93.294     | 93.294     |   0.0 | 99.18
Neigh   | 0.17978    | 0.17978    | 0.17978    |   0.0 |  0.19
Comm    | 0.089008   | 0.089008   | 0.089008   |   0.0 |  0.09
Output  | 0.00023515 | 0.00023515 | 0.00023515 |   0.0 |  0.00
Modify  | 0.44158    | 0.44158    | 0.44158    |   0.0 |  0.47
Other   |            | 0.06002    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2889 ave        2889 max        2889 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62714 ave       62714 max       62714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62714
Ave neighs/atom = 31.357
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.302185508606, Press = 0.925092076398832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -2081.5694     -2081.5694     -2151.3119     -2151.3119      269.91095      269.91095      77008.232      77008.232     -169.74032     -169.74032    
     14000  -2078.0256     -2078.0256     -2147.7101     -2147.7101      269.6864       269.6864       77040.783      77040.783      57.579166      57.579166    
Loop time of 94.3792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.915 ns/day, 26.216 hours/ns, 10.596 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    | 93.621     | 93.621     | 93.621     |   0.0 | 99.20
Neigh   | 0.16562    | 0.16562    | 0.16562    |   0.0 |  0.18
Comm    | 0.089744   | 0.089744   | 0.089744   |   0.0 |  0.10
Output  | 0.00023621 | 0.00023621 | 0.00023621 |   0.0 |  0.00
Modify  | 0.44168    | 0.44168    | 0.44168    |   0.0 |  0.47
Other   |            | 0.06105    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2884 ave        2884 max        2884 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62532 ave       62532 max       62532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62532
Ave neighs/atom = 31.266
Neighbor list builds = 11
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.278690567141, Press = -0.956360852936117
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -2078.0256     -2078.0256     -2147.7101     -2147.7101      269.6864       269.6864       77040.783      77040.783      57.579166      57.579166    
     15000  -2080.6786     -2080.6786     -2150.7439     -2150.7439      271.15983      271.15983      77048.559      77048.559     -109.11796     -109.11796    
Loop time of 84.2114 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.026 ns/day, 23.392 hours/ns, 11.875 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 83.525     | 83.525     | 83.525     |   0.0 | 99.18
Neigh   | 0.16933    | 0.16933    | 0.16933    |   0.0 |  0.20
Comm    | 0.081522   | 0.081522   | 0.081522   |   0.0 |  0.10
Output  | 0.00016928 | 0.00016928 | 0.00016928 |   0.0 |  0.00
Modify  | 0.38084    | 0.38084    | 0.38084    |   0.0 |  0.45
Other   |            | 0.0545     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2843 ave        2843 max        2843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        63028 ave       63028 max       63028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 63028
Ave neighs/atom = 31.514
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.267925027396, Press = 0.992879845715477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -2080.6786     -2080.6786     -2150.7439     -2150.7439      271.15983      271.15983      77048.559      77048.559     -109.11796     -109.11796    
     16000  -2078.5651     -2078.5651     -2148.3521     -2148.3521      270.0828       270.0828       76790.16       76790.16       234.07768      234.07768    
Loop time of 94.4618 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.915 ns/day, 26.239 hours/ns, 10.586 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.673     | 93.673     | 93.673     |   0.0 | 99.17
Neigh   | 0.19352    | 0.19352    | 0.19352    |   0.0 |  0.20
Comm    | 0.090468   | 0.090468   | 0.090468   |   0.0 |  0.10
Output  | 0.00022384 | 0.00022384 | 0.00022384 |   0.0 |  0.00
Modify  | 0.44442    | 0.44442    | 0.44442    |   0.0 |  0.47
Other   |            | 0.05977    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2875 ave        2875 max        2875 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62664 ave       62664 max       62664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62664
Ave neighs/atom = 31.332
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.194363695821, Press = -3.00469454431481
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -2078.5651     -2078.5651     -2148.3521     -2148.3521      270.0828       270.0828       76790.16       76790.16       234.07768      234.07768    
     17000  -2081.4031     -2081.4031     -2150.2847     -2150.2847      266.57878      266.57878      77147.585      77147.585     -297.65459     -297.65459    
Loop time of 93.5821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.923 ns/day, 25.995 hours/ns, 10.686 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.797     | 92.797     | 92.797     |   0.0 | 99.16
Neigh   | 0.19441    | 0.19441    | 0.19441    |   0.0 |  0.21
Comm    | 0.088285   | 0.088285   | 0.088285   |   0.0 |  0.09
Output  | 0.00022034 | 0.00022034 | 0.00022034 |   0.0 |  0.00
Modify  | 0.44163    | 0.44163    | 0.44163    |   0.0 |  0.47
Other   |            | 0.06023    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2898 ave        2898 max        2898 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62748 ave       62748 max       62748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62748
Ave neighs/atom = 31.374
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.211466821545, Press = 1.57985875520338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.326 | 3.326 | 3.326 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -2081.4031     -2081.4031     -2150.2847     -2150.2847      266.57878      266.57878      77147.585      77147.585     -297.65459     -297.65459    
     18000  -2080.6264     -2080.6264     -2149.4304     -2149.4304      266.27866      266.27866      76795.829      76795.829      142.58863      142.58863    
Loop time of 94.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.912 ns/day, 26.325 hours/ns, 10.552 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    | 93.994     | 93.994     | 93.994     |   0.0 | 99.18
Neigh   | 0.18012    | 0.18012    | 0.18012    |   0.0 |  0.19
Comm    | 0.090283   | 0.090283   | 0.090283   |   0.0 |  0.10
Output  | 0.00023845 | 0.00023845 | 0.00023845 |   0.0 |  0.00
Modify  | 0.44647    | 0.44647    | 0.44647    |   0.0 |  0.47
Other   |            | 0.05943    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2881 ave        2881 max        2881 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62386 ave       62386 max       62386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62386
Ave neighs/atom = 31.193
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.285838541023, Press = -0.208355842919727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -2080.6264     -2080.6264     -2149.4304     -2149.4304      266.27866      266.27866      76795.829      76795.829      142.58863      142.58863    
     19000  -2077.6168     -2077.6168     -2147.8337     -2147.8337      271.74673      271.74673      76994.327      76994.327      156.28315      156.28315    
Loop time of 94.8037 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.334 hours/ns, 10.548 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    | 94.029     | 94.029     | 94.029     |   0.0 | 99.18
Neigh   | 0.18055    | 0.18055    | 0.18055    |   0.0 |  0.19
Comm    | 0.091021   | 0.091021   | 0.091021   |   0.0 |  0.10
Output  | 0.00022102 | 0.00022102 | 0.00022102 |   0.0 |  0.00
Modify  | 0.44294    | 0.44294    | 0.44294    |   0.0 |  0.47
Other   |            | 0.05971    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2858 ave        2858 max        2858 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62636 ave       62636 max       62636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62636
Ave neighs/atom = 31.318
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.374242448838, Press = -0.971834152779507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -2077.6168     -2077.6168     -2147.8337     -2147.8337      271.74673      271.74673      76994.327      76994.327      156.28315      156.28315    
     20000  -2078.2838     -2078.2838     -2149.3328     -2149.3328      274.96697      274.96697      76854.677      76854.677      73.991926      73.991926    
Loop time of 94.6816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.913 ns/day, 26.300 hours/ns, 10.562 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    | 93.908     | 93.908     | 93.908     |   0.0 | 99.18
Neigh   | 0.18074    | 0.18074    | 0.18074    |   0.0 |  0.19
Comm    | 0.089074   | 0.089074   | 0.089074   |   0.0 |  0.09
Output  | 0.00016907 | 0.00016907 | 0.00016907 |   0.0 |  0.00
Modify  | 0.44388    | 0.44388    | 0.44388    |   0.0 |  0.47
Other   |            | 0.05991    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2886 ave        2886 max        2886 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62912 ave       62912 max       62912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62912
Ave neighs/atom = 31.456
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.493781749132, Press = 0.629759518205366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -2078.2838     -2078.2838     -2149.3328     -2149.3328      274.96697      274.96697      76854.677      76854.677      73.991926      73.991926    
     21000  -2076.3671     -2076.3671     -2146.4656     -2146.4656      271.28842      271.28842      77402.048      77402.048     -465.45983     -465.45983    
Loop time of 94.7292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.912 ns/day, 26.314 hours/ns, 10.556 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    | 93.951     | 93.951     | 93.951     |   0.0 | 99.18
Neigh   | 0.17974    | 0.17974    | 0.17974    |   0.0 |  0.19
Comm    | 0.091178   | 0.091178   | 0.091178   |   0.0 |  0.10
Output  | 0.00016935 | 0.00016935 | 0.00016935 |   0.0 |  0.00
Modify  | 0.44716    | 0.44716    | 0.44716    |   0.0 |  0.47
Other   |            | 0.05962    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2875 ave        2875 max        2875 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62114 ave       62114 max       62114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62114
Ave neighs/atom = 31.057
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.472420336724, Press = -1.42921140074478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -2076.3671     -2076.3671     -2146.4656     -2146.4656      271.28842      271.28842      77402.048      77402.048     -465.45983     -465.45983    
     22000  -2077.5389     -2077.5389     -2149.9306     -2149.9306      280.16332      280.16332      76631.341      76631.341      294.92686      294.92686    
Loop time of 94.8744 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.354 hours/ns, 10.540 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    | 94.082     | 94.082     | 94.082     |   0.0 | 99.17
Neigh   | 0.19549    | 0.19549    | 0.19549    |   0.0 |  0.21
Comm    | 0.090621   | 0.090621   | 0.090621   |   0.0 |  0.10
Output  | 0.00017416 | 0.00017416 | 0.00017416 |   0.0 |  0.00
Modify  | 0.44633    | 0.44633    | 0.44633    |   0.0 |  0.47
Other   |            | 0.0594     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2846 ave        2846 max        2846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        63446 ave       63446 max       63446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 63446
Ave neighs/atom = 31.723
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516497772522, Press = 1.39729287483308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -2077.5389     -2077.5389     -2149.9306     -2149.9306      280.16332      280.16332      76631.341      76631.341      294.92686      294.92686    
     23000  -2080.109      -2080.109      -2150.6489     -2150.6489      272.99667      272.99667      77042.175      77042.175     -113.27842     -113.27842    
Loop time of 94.8515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.348 hours/ns, 10.543 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    | 94.067     | 94.067     | 94.067     |   0.0 | 99.17
Neigh   | 0.19491    | 0.19491    | 0.19491    |   0.0 |  0.21
Comm    | 0.090034   | 0.090034   | 0.090034   |   0.0 |  0.09
Output  | 0.00021912 | 0.00021912 | 0.00021912 |   0.0 |  0.00
Modify  | 0.44057    | 0.44057    | 0.44057    |   0.0 |  0.46
Other   |            | 0.05918    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2866 ave        2866 max        2866 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62662 ave       62662 max       62662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62662
Ave neighs/atom = 31.331
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.439313873598, Press = -0.637784447924352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -2080.109      -2080.109      -2150.6489     -2150.6489      272.99667      272.99667      77042.175      77042.175     -113.27842     -113.27842    
     24000  -2079.0422     -2079.0422     -2150.4099     -2150.4099      276.20019      276.20019      76846.046      76846.046      57.666121      57.666121    
Loop time of 94.6124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.913 ns/day, 26.281 hours/ns, 10.569 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    | 93.835     | 93.835     | 93.835     |   0.0 | 99.18
Neigh   | 0.18073    | 0.18073    | 0.18073    |   0.0 |  0.19
Comm    | 0.089968   | 0.089968   | 0.089968   |   0.0 |  0.10
Output  | 0.0002581  | 0.0002581  | 0.0002581  |   0.0 |  0.00
Modify  | 0.44647    | 0.44647    | 0.44647    |   0.0 |  0.47
Other   |            | 0.05953    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2898 ave        2898 max        2898 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62968 ave       62968 max       62968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62968
Ave neighs/atom = 31.484
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.287027204174, Press = 0.39702554454954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -2079.0422     -2079.0422     -2150.4099     -2150.4099      276.20019      276.20019      76846.046      76846.046      57.666121      57.666121    
     25000  -2080.2841     -2080.2841     -2150.8042     -2150.8042      272.91998      272.91998      76792.463      76792.463      176.18203      176.18203    
Loop time of 93.3178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.926 ns/day, 25.922 hours/ns, 10.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.555     | 92.555     | 92.555     |   0.0 | 99.18
Neigh   | 0.17847    | 0.17847    | 0.17847    |   0.0 |  0.19
Comm    | 0.088398   | 0.088398   | 0.088398   |   0.0 |  0.09
Output  | 0.00016892 | 0.00016892 | 0.00016892 |   0.0 |  0.00
Modify  | 0.43631    | 0.43631    | 0.43631    |   0.0 |  0.47
Other   |            | 0.05991    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2856 ave        2856 max        2856 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62804 ave       62804 max       62804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62804
Ave neighs/atom = 31.402
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.266208619673, Press = -0.403672906306709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -2080.2841     -2080.2841     -2150.8042     -2150.8042      272.91998      272.91998      76792.463      76792.463      176.18203      176.18203    
     26000  -2080.7808     -2080.7808     -2149.217      -2149.217       264.85508      264.85508      77377.022      77377.022     -496.07503     -496.07503    
Loop time of 93.8948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.920 ns/day, 26.082 hours/ns, 10.650 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.128     | 93.128     | 93.128     |   0.0 | 99.18
Neigh   | 0.1775     | 0.1775     | 0.1775     |   0.0 |  0.19
Comm    | 0.088244   | 0.088244   | 0.088244   |   0.0 |  0.09
Output  | 0.00021726 | 0.00021726 | 0.00021726 |   0.0 |  0.00
Modify  | 0.44113    | 0.44113    | 0.44113    |   0.0 |  0.47
Other   |            | 0.05967    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2882 ave        2882 max        2882 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62564 ave       62564 max       62564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62564
Ave neighs/atom = 31.282
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.263502544424, Press = -0.463530808595147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -2080.7808     -2080.7808     -2149.217      -2149.217       264.85508      264.85508      77377.022      77377.022     -496.07503     -496.07503    
     27000  -2081.9273     -2081.9273     -2152.2259     -2152.2259      272.06273      272.06273      76620.375      76620.375      318.09126      318.09126    
Loop time of 93.8361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.921 ns/day, 26.066 hours/ns, 10.657 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.051     | 93.051     | 93.051     |   0.0 | 99.16
Neigh   | 0.19278    | 0.19278    | 0.19278    |   0.0 |  0.21
Comm    | 0.090016   | 0.090016   | 0.090016   |   0.0 |  0.10
Output  | 0.00021301 | 0.00021301 | 0.00021301 |   0.0 |  0.00
Modify  | 0.44233    | 0.44233    | 0.44233    |   0.0 |  0.47
Other   |            | 0.06016    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2860 ave        2860 max        2860 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        63124 ave       63124 max       63124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 63124
Ave neighs/atom = 31.562
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.208252775684, Press = 0.391051430940021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -2081.9273     -2081.9273     -2152.2259     -2152.2259      272.06273      272.06273      76620.375      76620.375      318.09126      318.09126    
     28000  -2077.5632     -2077.5632     -2145.9938     -2145.9938      264.83371      264.83371      77193.491      77193.491     -169.48238     -169.48238    
Loop time of 93.9459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.920 ns/day, 26.096 hours/ns, 10.644 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.175     | 93.175     | 93.175     |   0.0 | 99.18
Neigh   | 0.18066    | 0.18066    | 0.18066    |   0.0 |  0.19
Comm    | 0.089753   | 0.089753   | 0.089753   |   0.0 |  0.10
Output  | 0.00021901 | 0.00021901 | 0.00021901 |   0.0 |  0.00
Modify  | 0.44063    | 0.44063    | 0.44063    |   0.0 |  0.47
Other   |            | 0.05976    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2865 ave        2865 max        2865 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62552 ave       62552 max       62552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62552
Ave neighs/atom = 31.276
Neighbor list builds = 12
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.124956490873, Press = -0.516144935115752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -2077.5632     -2077.5632     -2145.9938     -2145.9938      264.83371      264.83371      77193.491      77193.491     -169.48238     -169.48238    
     29000  -2080.3048     -2080.3048     -2150.713      -2150.713       272.48688      272.48688      76849.62       76849.62      -110.75585     -110.75585    
Loop time of 93.7417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.922 ns/day, 26.039 hours/ns, 10.668 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.958     | 92.958     | 92.958     |   0.0 | 99.16
Neigh   | 0.19249    | 0.19249    | 0.19249    |   0.0 |  0.21
Comm    | 0.089442   | 0.089442   | 0.089442   |   0.0 |  0.10
Output  | 0.00017045 | 0.00017045 | 0.00017045 |   0.0 |  0.00
Modify  | 0.44159    | 0.44159    | 0.44159    |   0.0 |  0.47
Other   |            | 0.05967    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2892 ave        2892 max        2892 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62892 ave       62892 max       62892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 62892
Ave neighs/atom = 31.446
Neighbor list builds = 13
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.143736404257, Press = 0.397940810633949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.325 | 3.325 | 3.325 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -2080.3048     -2080.3048     -2150.713      -2150.713       272.48688      272.48688      76849.62       76849.62      -110.75585     -110.75585    
     30000  -2078.9125     -2078.9125     -2150.5347     -2150.5347      277.1854       277.1854       77074.954      77074.954     -185.38761     -185.38761    
Loop time of 93.5151 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.924 ns/day, 25.976 hours/ns, 10.693 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    | 92.748     | 92.748     | 92.748     |   0.0 | 99.18
Neigh   | 0.17987    | 0.17987    | 0.17987    |   0.0 |  0.19
Comm    | 0.087976   | 0.087976   | 0.087976   |   0.0 |  0.09
Output  | 0.00017514 | 0.00017514 | 0.00017514 |   0.0 |  0.00
Modify  | 0.43827    | 0.43827    | 0.43827    |   0.0 |  0.47
Other   |            | 0.06089    |            |       |  0.07

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2870 ave        2870 max        2870 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:        62546 ave       62546 max       62546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0