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

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

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

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_FuemmelerVita_2023_Li__MO_386038428339_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 40776.9268957422 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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_386038428339_000#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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3731.7424     -3731.7424     -3797.1541     -3797.1541      253.15         253.15         40776.927      40776.927      1713.4081      1713.4081    
      1000  -3665.6301     -3665.6301     -3730.0685     -3730.0685      249.38321      249.38321      41862.441      41862.441     -561.22681     -561.22681    
Loop time of 117.429 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.619 hours/ns, 8.516 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    | 116.6      | 116.6      | 116.6      |   0.0 | 99.29
Neigh   | 0.34132    | 0.34132    | 0.34132    |   0.0 |  0.29
Comm    | 0.093953   | 0.093953   | 0.093953   |   0.0 |  0.08
Output  | 0.00028706 | 0.00028706 | 0.00028706 |   0.0 |  0.00
Modify  | 0.33447    | 0.33447    | 0.33447    |   0.0 |  0.28
Other   |            | 0.05935    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3836 ave        3836 max        3836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126756 ave      126756 max      126756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126756
Ave neighs/atom = 63.378
Neighbor list builds = 14
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3665.6301     -3665.6301     -3730.0685     -3730.0685      249.38321      249.38321      41862.441      41862.441     -561.22681     -561.22681    
      2000  -3665.0954     -3665.0954     -3730.6856     -3730.6856      253.84098      253.84098      41543.335      41543.335      420.34245      420.34245    
Loop time of 114.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.734 hours/ns, 8.753 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    | 113.26     | 113.26     | 113.26     |   0.0 | 99.14
Neigh   | 0.4915     | 0.4915     | 0.4915     |   0.0 |  0.43
Comm    | 0.096468   | 0.096468   | 0.096468   |   0.0 |  0.08
Output  | 0.00025749 | 0.00025749 | 0.00025749 |   0.0 |  0.00
Modify  | 0.33474    | 0.33474    | 0.33474    |   0.0 |  0.29
Other   |            | 0.0586     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3880 ave        3880 max        3880 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127370 ave      127370 max      127370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127370
Ave neighs/atom = 63.685
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3665.0954     -3665.0954     -3730.6856     -3730.6856      253.84098      253.84098      41543.335      41543.335      420.34245      420.34245    
      3000  -3665.5168     -3665.5168     -3731.7142     -3731.7142      256.1908       256.1908       41810.796      41810.796     -469.63879     -469.63879    
Loop time of 113.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.654 hours/ns, 8.775 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    | 112.97     | 112.97     | 112.97     |   0.0 | 99.14
Neigh   | 0.4911     | 0.4911     | 0.4911     |   0.0 |  0.43
Comm    | 0.096154   | 0.096154   | 0.096154   |   0.0 |  0.08
Output  | 0.00025092 | 0.00025092 | 0.00025092 |   0.0 |  0.00
Modify  | 0.33373    | 0.33373    | 0.33373    |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3818 ave        3818 max        3818 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126658 ave      126658 max      126658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126658
Ave neighs/atom = 63.329
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3665.5168     -3665.5168     -3731.7142     -3731.7142      256.1908       256.1908       41810.796      41810.796     -469.63879     -469.63879    
      4000  -3664.5995     -3664.5995     -3730.4265     -3730.4265      254.7572       254.7572       41582.968      41582.968      310.49895      310.49895    
Loop time of 114.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.682 hours/ns, 8.768 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    | 113.13     | 113.13     | 113.13     |   0.0 | 99.19
Neigh   | 0.44318    | 0.44318    | 0.44318    |   0.0 |  0.39
Comm    | 0.095425   | 0.095425   | 0.095425   |   0.0 |  0.08
Output  | 0.00020765 | 0.00020765 | 0.00020765 |   0.0 |  0.00
Modify  | 0.33238    | 0.33238    | 0.33238    |   0.0 |  0.29
Other   |            | 0.05813    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3838 ave        3838 max        3838 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127236 ave      127236 max      127236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127236
Ave neighs/atom = 63.618
Neighbor list builds = 18
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3664.5995     -3664.5995     -3730.4265     -3730.4265      254.7572       254.7572       41582.968      41582.968      310.49895      310.49895    
      5000  -3665.7963     -3665.7963     -3731.7948     -3731.7948      255.42096      255.42096      41779.464      41779.464     -335.30864     -335.30864    
Loop time of 124.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.462 hours/ns, 8.060 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    | 123        | 123        | 123        |   0.0 | 99.14
Neigh   | 0.49736    | 0.49736    | 0.49736    |   0.0 |  0.40
Comm    | 0.10578    | 0.10578    | 0.10578    |   0.0 |  0.09
Output  | 0.00016892 | 0.00016892 | 0.00016892 |   0.0 |  0.00
Modify  | 0.39712    | 0.39712    | 0.39712    |   0.0 |  0.32
Other   |            | 0.06263    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3832 ave        3832 max        3832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127102 ave      127102 max      127102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127102
Ave neighs/atom = 63.551
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 250.732750009525, Press = -121.177494602557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3665.7963     -3665.7963     -3731.7948     -3731.7948      255.42096      255.42096      41779.464      41779.464     -335.30864     -335.30864    
      6000  -3663.3513     -3663.3513     -3731.2503     -3731.2503      262.77633      262.77633      41559.155      41559.155      533.59307      533.59307    
Loop time of 119.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.276 hours/ns, 8.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.73     | 118.73     | 118.73     |   0.0 | 99.11
Neigh   | 0.50908    | 0.50908    | 0.50908    |   0.0 |  0.42
Comm    | 0.1045     | 0.1045     | 0.1045     |   0.0 |  0.09
Output  | 0.00017062 | 0.00017062 | 0.00017062 |   0.0 |  0.00
Modify  | 0.39187    | 0.39187    | 0.39187    |   0.0 |  0.33
Other   |            | 0.06105    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3840 ave        3840 max        3840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127222 ave      127222 max      127222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127222
Ave neighs/atom = 63.611
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.988101818524, Press = -46.7552221375596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3663.3513     -3663.3513     -3731.2503     -3731.2503      262.77633      262.77633      41559.155      41559.155      533.59307      533.59307    
      7000  -3665.8887     -3665.8887     -3732.2033     -3732.2033      256.64467      256.64467      41820.239      41820.239     -448.32513     -448.32513    
Loop time of 114.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.788 hours/ns, 8.738 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    | 113.43     | 113.43     | 113.43     |   0.0 | 99.12
Neigh   | 0.49398    | 0.49398    | 0.49398    |   0.0 |  0.43
Comm    | 0.098013   | 0.098013   | 0.098013   |   0.0 |  0.09
Output  | 0.00021579 | 0.00021579 | 0.00021579 |   0.0 |  0.00
Modify  | 0.35794    | 0.35794    | 0.35794    |   0.0 |  0.31
Other   |            | 0.05837    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3831 ave        3831 max        3831 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126562 ave      126562 max      126562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126562
Ave neighs/atom = 63.281
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.72662158792, Press = 2.16967063145739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3665.8887     -3665.8887     -3732.2033     -3732.2033      256.64467      256.64467      41820.239      41820.239     -448.32513     -448.32513    
      8000  -3663.0005     -3663.0005     -3730.4166     -3730.4166      260.90735      260.90735      41648.288      41648.288      233.5076       233.5076     
Loop time of 114.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.782 hours/ns, 8.740 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    | 113.41     | 113.41     | 113.41     |   0.0 | 99.12
Neigh   | 0.49445    | 0.49445    | 0.49445    |   0.0 |  0.43
Comm    | 0.098462   | 0.098462   | 0.098462   |   0.0 |  0.09
Output  | 0.00021182 | 0.00021182 | 0.00021182 |   0.0 |  0.00
Modify  | 0.35742    | 0.35742    | 0.35742    |   0.0 |  0.31
Other   |            | 0.05807    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3861 ave        3861 max        3861 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127116 ave      127116 max      127116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127116
Ave neighs/atom = 63.558
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.770138988222, Press = -12.7456761173861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3663.0005     -3663.0005     -3730.4166     -3730.4166      260.90735      260.90735      41648.288      41648.288      233.5076       233.5076     
      9000  -3664.7747     -3664.7747     -3731.2914     -3731.2914      257.42629      257.42629      41753.969      41753.969     -268.3727      -268.3727     
Loop time of 114.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.803 hours/ns, 8.734 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    | 113.48     | 113.48     | 113.48     |   0.0 | 99.12
Neigh   | 0.49342    | 0.49342    | 0.49342    |   0.0 |  0.43
Comm    | 0.099292   | 0.099292   | 0.099292   |   0.0 |  0.09
Output  | 0.00017116 | 0.00017116 | 0.00017116 |   0.0 |  0.00
Modify  | 0.35823    | 0.35823    | 0.35823    |   0.0 |  0.31
Other   |            | 0.0579     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3843 ave        3843 max        3843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126888 ave      126888 max      126888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126888
Ave neighs/atom = 63.444
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.539696258517, Press = -3.77272162230197
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3664.7747     -3664.7747     -3731.2914     -3731.2914      257.42629      257.42629      41753.969      41753.969     -268.3727      -268.3727     
     10000  -3662.7478     -3662.7478     -3729.7257     -3729.7257      259.2114       259.2114       41722.678      41722.678     -16.47939      -16.47939     
Loop time of 114.647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.846 hours/ns, 8.722 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    | 113.64     | 113.64     | 113.64     |   0.0 | 99.12
Neigh   | 0.49511    | 0.49511    | 0.49511    |   0.0 |  0.43
Comm    | 0.09928    | 0.09928    | 0.09928    |   0.0 |  0.09
Output  | 0.00021459 | 0.00021459 | 0.00021459 |   0.0 |  0.00
Modify  | 0.35668    | 0.35668    | 0.35668    |   0.0 |  0.31
Other   |            | 0.05869    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3843 ave        3843 max        3843 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126954 ave      126954 max      126954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126954
Ave neighs/atom = 63.477
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.213004705492, Press = -3.99049074821656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3662.7478     -3662.7478     -3729.7257     -3729.7257      259.2114       259.2114       41722.678      41722.678     -16.47939      -16.47939     
     11000  -3664.4173     -3664.4173     -3730.803      -3730.803       256.91953      256.91953      41710.091      41710.091     -58.016764     -58.016764    
Loop time of 114.526 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.813 hours/ns, 8.732 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    | 113.54     | 113.54     | 113.54     |   0.0 | 99.14
Neigh   | 0.4693     | 0.4693     | 0.4693     |   0.0 |  0.41
Comm    | 0.099027   | 0.099027   | 0.099027   |   0.0 |  0.09
Output  | 0.00017276 | 0.00017276 | 0.00017276 |   0.0 |  0.00
Modify  | 0.35684    | 0.35684    | 0.35684    |   0.0 |  0.31
Other   |            | 0.05894    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3841 ave        3841 max        3841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126810 ave      126810 max      126810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126810
Ave neighs/atom = 63.405
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.256692773904, Press = -3.65317170601954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3664.4173     -3664.4173     -3730.803      -3730.803       256.91953      256.91953      41710.091      41710.091     -58.016764     -58.016764    
     12000  -3666.8101     -3666.8101     -3733.3745     -3733.3745      257.61099      257.61099      41660.229      41660.229      91.067057      91.067057    
Loop time of 114.604 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.835 hours/ns, 8.726 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    | 113.62     | 113.62     | 113.62     |   0.0 | 99.14
Neigh   | 0.46917    | 0.46917    | 0.46917    |   0.0 |  0.41
Comm    | 0.098647   | 0.098647   | 0.098647   |   0.0 |  0.09
Output  | 0.00017125 | 0.00017125 | 0.00017125 |   0.0 |  0.00
Modify  | 0.35803    | 0.35803    | 0.35803    |   0.0 |  0.31
Other   |            | 0.05867    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3870 ave        3870 max        3870 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126992 ave      126992 max      126992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126992
Ave neighs/atom = 63.496
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.15487904468, Press = -1.43497659341681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3666.8101     -3666.8101     -3733.3745     -3733.3745      257.61099      257.61099      41660.229      41660.229      91.067057      91.067057    
     13000  -3665.1026     -3665.1026     -3729.6152     -3729.6152      249.67051      249.67051      41726.849      41726.849     -49.174633     -49.174633    
Loop time of 114.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.750 hours/ns, 8.749 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    | 113.32     | 113.32     | 113.32     |   0.0 | 99.14
Neigh   | 0.46872    | 0.46872    | 0.46872    |   0.0 |  0.41
Comm    | 0.098929   | 0.098929   | 0.098929   |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.35694    | 0.35694    | 0.35694    |   0.0 |  0.31
Other   |            | 0.05871    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3866 ave        3866 max        3866 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127172 ave      127172 max      127172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127172
Ave neighs/atom = 63.586
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.349589988541, Press = -2.43035883463161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3665.1026     -3665.1026     -3729.6152     -3729.6152      249.67051      249.67051      41726.849      41726.849     -49.174633     -49.174633    
     14000  -3666.5703     -3666.5703     -3731.7848     -3731.7848      252.38696      252.38696      41595.025      41595.025      265.28175      265.28175    
Loop time of 114.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.813 hours/ns, 8.732 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    | 113.52     | 113.52     | 113.52     |   0.0 | 99.12
Neigh   | 0.49336    | 0.49336    | 0.49336    |   0.0 |  0.43
Comm    | 0.098693   | 0.098693   | 0.098693   |   0.0 |  0.09
Output  | 0.00016971 | 0.00016971 | 0.00016971 |   0.0 |  0.00
Modify  | 0.35804    | 0.35804    | 0.35804    |   0.0 |  0.31
Other   |            | 0.05872    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3856 ave        3856 max        3856 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127152 ave      127152 max      127152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127152
Ave neighs/atom = 63.576
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.473743241375, Press = -2.67063515164582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3666.5703     -3666.5703     -3731.7848     -3731.7848      252.38696      252.38696      41595.025      41595.025      265.28175      265.28175    
     15000  -3667.8721     -3667.8721     -3732.8006     -3732.8006      251.27989      251.27989      41739.322      41739.322     -272.39083     -272.39083    
Loop time of 114.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.813 hours/ns, 8.732 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    | 113.52     | 113.52     | 113.52     |   0.0 | 99.12
Neigh   | 0.49335    | 0.49335    | 0.49335    |   0.0 |  0.43
Comm    | 0.098588   | 0.098588   | 0.098588   |   0.0 |  0.09
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.35799    | 0.35799    | 0.35799    |   0.0 |  0.31
Other   |            | 0.05853    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3848 ave        3848 max        3848 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126974 ave      126974 max      126974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126974
Ave neighs/atom = 63.487
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.468337258714, Press = -0.459042452768538
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3667.8721     -3667.8721     -3732.8006     -3732.8006      251.27989      251.27989      41739.322      41739.322     -272.39083     -272.39083    
     16000  -3665.0715     -3665.0715     -3731.3507     -3731.3507      256.50739      256.50739      41582.53       41582.53       396.984        396.984      
Loop time of 115.083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.968 hours/ns, 8.689 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    | 114.1      | 114.1      | 114.1      |   0.0 | 99.14
Neigh   | 0.46962    | 0.46962    | 0.46962    |   0.0 |  0.41
Comm    | 0.098843   | 0.098843   | 0.098843   |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.35693    | 0.35693    | 0.35693    |   0.0 |  0.31
Other   |            | 0.05949    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3864 ave        3864 max        3864 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127164 ave      127164 max      127164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127164
Ave neighs/atom = 63.582
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.217801529515, Press = -3.06891521808559
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3665.0715     -3665.0715     -3731.3507     -3731.3507      256.50739      256.50739      41582.53       41582.53       396.984        396.984      
     17000  -3666.209      -3666.209      -3731.6507     -3731.6507      253.26592      253.26592      41738.964      41738.964     -163.96143     -163.96143    
Loop time of 115.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.965 hours/ns, 8.690 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    | 114.09     | 114.09     | 114.09     |   0.0 | 99.15
Neigh   | 0.46856    | 0.46856    | 0.46856    |   0.0 |  0.41
Comm    | 0.098583   | 0.098583   | 0.098583   |   0.0 |  0.09
Output  | 0.0001702  | 0.0001702  | 0.0001702  |   0.0 |  0.00
Modify  | 0.35763    | 0.35763    | 0.35763    |   0.0 |  0.31
Other   |            | 0.05884    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3872 ave        3872 max        3872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126826 ave      126826 max      126826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126826
Ave neighs/atom = 63.413
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.103971498985, Press = -0.61584208125824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3666.209      -3666.209      -3731.6507     -3731.6507      253.26592      253.26592      41738.964      41738.964     -163.96143     -163.96143    
     18000  -3664.1908     -3664.1908     -3730.9286     -3730.9286      258.28211      258.28211      41711.006      41711.006     -82.440935     -82.440935    
Loop time of 114.814 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.893 hours/ns, 8.710 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    | 113.81     | 113.81     | 113.81     |   0.0 | 99.12
Neigh   | 0.49389    | 0.49389    | 0.49389    |   0.0 |  0.43
Comm    | 0.098776   | 0.098776   | 0.098776   |   0.0 |  0.09
Output  | 0.00016904 | 0.00016904 | 0.00016904 |   0.0 |  0.00
Modify  | 0.35771    | 0.35771    | 0.35771    |   0.0 |  0.31
Other   |            | 0.05856    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3779 ave        3779 max        3779 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126856 ave      126856 max      126856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126856
Ave neighs/atom = 63.428
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.028479638691, Press = -4.99653411843381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3664.1908     -3664.1908     -3730.9286     -3730.9286      258.28211      258.28211      41711.006      41711.006     -82.440935     -82.440935    
     19000  -3667.513      -3667.513      -3731.2291     -3731.2291      246.58776      246.58776      41637.492      41637.492      182.36379      182.36379    
Loop time of 115.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.966 hours/ns, 8.690 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.04     | 114.04     | 114.04     |   0.0 | 99.10
Neigh   | 0.51824    | 0.51824    | 0.51824    |   0.0 |  0.45
Comm    | 0.098707   | 0.098707   | 0.098707   |   0.0 |  0.09
Output  | 0.00017126 | 0.00017126 | 0.00017126 |   0.0 |  0.00
Modify  | 0.35791    | 0.35791    | 0.35791    |   0.0 |  0.31
Other   |            | 0.05868    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3907 ave        3907 max        3907 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127338 ave      127338 max      127338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127338
Ave neighs/atom = 63.669
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.032658839641, Press = 3.67500707096726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3667.513      -3667.513      -3731.2291     -3731.2291      246.58776      246.58776      41637.492      41637.492      182.36379      182.36379    
     20000  -3661.9183     -3661.9183     -3728.2092     -3728.2092      256.55269      256.55269      41771.755      41771.755     -149.95933     -149.95933    
Loop time of 114.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.857 hours/ns, 8.719 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.68     | 113.68     | 113.68     |   0.0 | 99.12
Neigh   | 0.49324    | 0.49324    | 0.49324    |   0.0 |  0.43
Comm    | 0.09883    | 0.09883    | 0.09883    |   0.0 |  0.09
Output  | 0.00016942 | 0.00016942 | 0.00016942 |   0.0 |  0.00
Modify  | 0.35825    | 0.35825    | 0.35825    |   0.0 |  0.31
Other   |            | 0.05806    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3814 ave        3814 max        3814 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126810 ave      126810 max      126810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126810
Ave neighs/atom = 63.405
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.140143508228, Press = -2.58919716536549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3661.9183     -3661.9183     -3728.2092     -3728.2092      256.55269      256.55269      41771.755      41771.755     -149.95933     -149.95933    
     21000  -3665.7626     -3665.7626     -3731.1141     -3731.1141      252.91699      252.91699      41698.089      41698.089      8.7849889      8.7849889    
Loop time of 114.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.784 hours/ns, 8.740 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.41     | 113.41     | 113.41     |   0.0 | 99.12
Neigh   | 0.4931     | 0.4931     | 0.4931     |   0.0 |  0.43
Comm    | 0.099399   | 0.099399   | 0.099399   |   0.0 |  0.09
Output  | 0.00021378 | 0.00021378 | 0.00021378 |   0.0 |  0.00
Modify  | 0.35633    | 0.35633    | 0.35633    |   0.0 |  0.31
Other   |            | 0.05873    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3874 ave        3874 max        3874 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127038 ave      127038 max      127038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127038
Ave neighs/atom = 63.519
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.202390242677, Press = 0.4064387989826
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3665.7626     -3665.7626     -3731.1141     -3731.1141      252.91699      252.91699      41698.089      41698.089      8.7849889      8.7849889    
     22000  -3662.2551     -3662.2551     -3728.7972     -3728.7972      257.52497      257.52497      41771.008      41771.008     -125.30433     -125.30433    
Loop time of 114.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.744 hours/ns, 8.751 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    | 113.27     | 113.27     | 113.27     |   0.0 | 99.12
Neigh   | 0.4934     | 0.4934     | 0.4934     |   0.0 |  0.43
Comm    | 0.098359   | 0.098359   | 0.098359   |   0.0 |  0.09
Output  | 0.00021637 | 0.00021637 | 0.00021637 |   0.0 |  0.00
Modify  | 0.35655    | 0.35655    | 0.35655    |   0.0 |  0.31
Other   |            | 0.05882    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3833 ave        3833 max        3833 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126996 ave      126996 max      126996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126996
Ave neighs/atom = 63.498
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.318707219883, Press = -2.99389737779245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3662.2551     -3662.2551     -3728.7972     -3728.7972      257.52497      257.52497      41771.008      41771.008     -125.30433     -125.30433    
     23000  -3665.5722     -3665.5722     -3731.3434     -3731.3434      254.5413       254.5413       41598.495      41598.495      334.47499      334.47499    
Loop time of 114.58 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.754 ns/day, 31.828 hours/ns, 8.728 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    | 113.57     | 113.57     | 113.57     |   0.0 | 99.12
Neigh   | 0.49318    | 0.49318    | 0.49318    |   0.0 |  0.43
Comm    | 0.098484   | 0.098484   | 0.098484   |   0.0 |  0.09
Output  | 0.00017087 | 0.00017087 | 0.00017087 |   0.0 |  0.00
Modify  | 0.35675    | 0.35675    | 0.35675    |   0.0 |  0.31
Other   |            | 0.05825    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3804 ave        3804 max        3804 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127516 ave      127516 max      127516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127516
Ave neighs/atom = 63.758
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.344692461552, Press = 1.22113545914034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3665.5722     -3665.5722     -3731.3434     -3731.3434      254.5413       254.5413       41598.495      41598.495      334.47499      334.47499    
     24000  -3665.2456     -3665.2456     -3729.448      -3729.448       248.46989      248.46989      41821.354      41821.354     -398.25671     -398.25671    
Loop time of 114.463 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.795 hours/ns, 8.736 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    | 113.45     | 113.45     | 113.45     |   0.0 | 99.12
Neigh   | 0.49553    | 0.49553    | 0.49553    |   0.0 |  0.43
Comm    | 0.098749   | 0.098749   | 0.098749   |   0.0 |  0.09
Output  | 0.00016982 | 0.00016982 | 0.00016982 |   0.0 |  0.00
Modify  | 0.35818    | 0.35818    | 0.35818    |   0.0 |  0.31
Other   |            | 0.05886    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3854 ave        3854 max        3854 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126792 ave      126792 max      126792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126792
Ave neighs/atom = 63.396
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.454461638699, Press = -3.25965029685052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3665.2456     -3665.2456     -3729.448      -3729.448       248.46989      248.46989      41821.354      41821.354     -398.25671     -398.25671    
     25000  -3663.8157     -3663.8157     -3729.5397     -3729.5397      254.35864      254.35864      41635.075      41635.075      266.46022      266.46022    
Loop time of 114.836 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.752 ns/day, 31.899 hours/ns, 8.708 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    | 113.85     | 113.85     | 113.85     |   0.0 | 99.14
Neigh   | 0.46916    | 0.46916    | 0.46916    |   0.0 |  0.41
Comm    | 0.098037   | 0.098037   | 0.098037   |   0.0 |  0.09
Output  | 0.00017348 | 0.00017348 | 0.00017348 |   0.0 |  0.00
Modify  | 0.3573     | 0.3573     | 0.3573     |   0.0 |  0.31
Other   |            | 0.05886    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3832 ave        3832 max        3832 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127082 ave      127082 max      127082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127082
Ave neighs/atom = 63.541
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.497789819576, Press = 1.10232762098503
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3663.8157     -3663.8157     -3729.5397     -3729.5397      254.35864      254.35864      41635.075      41635.075      266.46022      266.46022    
     26000  -3665.6114     -3665.6114     -3731.0485     -3731.0485      253.24814      253.24814      41713.758      41713.758     -123.05009     -123.05009    
Loop time of 114.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.808 hours/ns, 8.733 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    | 113.53     | 113.53     | 113.53     |   0.0 | 99.14
Neigh   | 0.4685     | 0.4685     | 0.4685     |   0.0 |  0.41
Comm    | 0.097968   | 0.097968   | 0.097968   |   0.0 |  0.09
Output  | 0.00021594 | 0.00021594 | 0.00021594 |   0.0 |  0.00
Modify  | 0.35811    | 0.35811    | 0.35811    |   0.0 |  0.31
Other   |            | 0.05868    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3897 ave        3897 max        3897 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126998 ave      126998 max      126998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126998
Ave neighs/atom = 63.499
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.491658287996, Press = -1.30247298231581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3665.6114     -3665.6114     -3731.0485     -3731.0485      253.24814      253.24814      41713.758      41713.758     -123.05009     -123.05009    
     27000  -3663.5478     -3663.5478     -3729.8391     -3729.8391      256.55404      256.55404      41705.074      41705.074     -72.615747     -72.615747    
Loop time of 114.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.752 ns/day, 31.918 hours/ns, 8.703 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    | 113.92     | 113.92     | 113.92     |   0.0 | 99.14
Neigh   | 0.46858    | 0.46858    | 0.46858    |   0.0 |  0.41
Comm    | 0.097716   | 0.097716   | 0.097716   |   0.0 |  0.09
Output  | 0.00017276 | 0.00017276 | 0.00017276 |   0.0 |  0.00
Modify  | 0.35804    | 0.35804    | 0.35804    |   0.0 |  0.31
Other   |            | 0.05884    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3872 ave        3872 max        3872 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127058 ave      127058 max      127058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127058
Ave neighs/atom = 63.529
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.547071734899, Press = 0.08788343413846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3663.5478     -3663.5478     -3729.8391     -3729.8391      256.55404      256.55404      41705.074      41705.074     -72.615747     -72.615747    
     28000  -3668.6409     -3668.6409     -3732.2955     -3732.2955      246.34994      246.34994      41730.504      41730.504     -206.23609     -206.23609    
Loop time of 114.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.752 ns/day, 31.911 hours/ns, 8.705 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    | 113.9      | 113.9      | 113.9      |   0.0 | 99.15
Neigh   | 0.46758    | 0.46758    | 0.46758    |   0.0 |  0.41
Comm    | 0.09829    | 0.09829    | 0.09829    |   0.0 |  0.09
Output  | 0.00021482 | 0.00021482 | 0.00021482 |   0.0 |  0.00
Modify  | 0.35736    | 0.35736    | 0.35736    |   0.0 |  0.31
Other   |            | 0.05866    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3841 ave        3841 max        3841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126610 ave      126610 max      126610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126610
Ave neighs/atom = 63.305
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.457873656088, Press = -1.85260893124159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3668.6409     -3668.6409     -3732.2955     -3732.2955      246.34994      246.34994      41730.504      41730.504     -206.23609     -206.23609    
     29000  -3664.7839     -3664.7839     -3729.8273     -3729.8273      251.72484      251.72484      41652.843      41652.843      198.45821      198.45821    
Loop time of 114.753 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.753 ns/day, 31.876 hours/ns, 8.714 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    | 113.74     | 113.74     | 113.74     |   0.0 | 99.12
Neigh   | 0.49349    | 0.49349    | 0.49349    |   0.0 |  0.43
Comm    | 0.099077   | 0.099077   | 0.099077   |   0.0 |  0.09
Output  | 0.00016992 | 0.00016992 | 0.00016992 |   0.0 |  0.00
Modify  | 0.35753    | 0.35753    | 0.35753    |   0.0 |  0.31
Other   |            | 0.05833    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3841 ave        3841 max        3841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127264 ave      127264 max      127264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127264
Ave neighs/atom = 63.632
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.390547661621, Press = 0.44843708127818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3664.7839     -3664.7839     -3729.8273     -3729.8273      251.72484      251.72484      41652.843      41652.843      198.45821      198.45821    
     30000  -3667.7293     -3667.7293     -3731.1092     -3731.1092      245.28686      245.28686      41763.931      41763.931     -327.35223     -327.35223    
Loop time of 114.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.752 ns/day, 31.924 hours/ns, 8.701 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    | 113.92     | 113.92     | 113.92     |   0.0 | 99.12
Neigh   | 0.4932     | 0.4932     | 0.4932     |   0.0 |  0.43
Comm    | 0.098702   | 0.098702   | 0.098702   |   0.0 |  0.09
Output  | 0.00020958 | 0.00020958 | 0.00020958 |   0.0 |  0.00
Modify  | 0.35631    | 0.35631    | 0.35631    |   0.0 |  0.31
Other   |            | 0.05904    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3805 ave        3805 max        3805 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126936 ave      126936 max      126936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126936
Ave neighs/atom = 63.468
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.276243119636, Press = -2.61936513795059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3667.7293     -3667.7293     -3731.1092     -3731.1092      245.28686      245.28686      41763.931      41763.931     -327.35223     -327.35223    
     31000  -3663.3901     -3663.3901     -3728.9119     -3728.9119      253.57598      253.57598      41701.269      41701.269      51.362889      51.362889    
Loop time of 114.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.751 ns/day, 31.940 hours/ns, 8.697 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    | 114        | 114        | 114        |   0.0 | 99.14
Neigh   | 0.46863    | 0.46863    | 0.46863    |   0.0 |  0.41
Comm    | 0.098263   | 0.098263   | 0.098263   |   0.0 |  0.09
Output  | 0.00017015 | 0.00017015 | 0.00017015 |   0.0 |  0.00
Modify  | 0.35808    | 0.35808    | 0.35808    |   0.0 |  0.31
Other   |            | 0.05827    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3840 ave        3840 max        3840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127056 ave      127056 max      127056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127056
Ave neighs/atom = 63.528
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.293059071592, Press = 0.944114474356809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3663.3901     -3663.3901     -3728.9119     -3728.9119      253.57598      253.57598      41701.269      41701.269      51.362889      51.362889    
     32000  -3663.9596     -3663.9596     -3729.8465     -3729.8465      254.98905      254.98905      41712.417      41712.417      71.845237      71.845237    
Loop time of 114.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.793 hours/ns, 8.737 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    | 113.47     | 113.47     | 113.47     |   0.0 | 99.14
Neigh   | 0.46835    | 0.46835    | 0.46835    |   0.0 |  0.41
Comm    | 0.098647   | 0.098647   | 0.098647   |   0.0 |  0.09
Output  | 0.00017033 | 0.00017033 | 0.00017033 |   0.0 |  0.00
Modify  | 0.35884    | 0.35884    | 0.35884    |   0.0 |  0.31
Other   |            | 0.05859    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3856 ave        3856 max        3856 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126866 ave      126866 max      126866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126866
Ave neighs/atom = 63.433
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.260730125761, Press = -1.07283183069917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3663.9596     -3663.9596     -3729.8465     -3729.8465      254.98905      254.98905      41712.417      41712.417      71.845237      71.845237    
     33000  -3666.5467     -3666.5467     -3730.3875     -3730.3875      247.07081      247.07081      41674.085      41674.085      52.291432      52.291432    
Loop time of 114.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.804 hours/ns, 8.734 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    | 113.49     | 113.49     | 113.49     |   0.0 | 99.12
Neigh   | 0.49422    | 0.49422    | 0.49422    |   0.0 |  0.43
Comm    | 0.098434   | 0.098434   | 0.098434   |   0.0 |  0.09
Output  | 0.00020875 | 0.00020875 | 0.00020875 |   0.0 |  0.00
Modify  | 0.35591    | 0.35591    | 0.35591    |   0.0 |  0.31
Other   |            | 0.05847    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3834 ave        3834 max        3834 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126920 ave      126920 max      126920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126920
Ave neighs/atom = 63.46
Neighbor list builds = 20
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
41695.2261622057

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0