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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.303000025451184*${_u_distance}
variable latticeconst_converted equal 3.303000025451184*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30300002545118
Lattice spacing in x,y,z = 3.303 3.303 3.303
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.03 33.03 33.03)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (33.03 33.03 33.03)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Ta

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

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


mass          1 ${mass_converted}
mass          1 180.9479

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

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

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

variable temp_converted equal 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_112077942578_002#item-citation

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

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

Performance: 0.560 ns/day, 42.857 hours/ns, 6.481 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    | 153.79     | 153.79     | 153.79     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094216   | 0.094216   | 0.094216   |   0.0 |  0.06
Output  | 0.00021389 | 0.00021389 | 0.00021389 |   0.0 |  0.00
Modify  | 0.34672    | 0.34672    | 0.34672    |   0.0 |  0.22
Other   |            | 0.05975    |            |       |  0.04

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

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

Performance: 0.577 ns/day, 41.561 hours/ns, 6.684 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.12     | 149.12     | 149.12     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098119   | 0.098119   | 0.098119   |   0.0 |  0.07
Output  | 0.00021428 | 0.00021428 | 0.00021428 |   0.0 |  0.00
Modify  | 0.33965    | 0.33965    | 0.33965    |   0.0 |  0.23
Other   |            | 0.05903    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.74     | 148.74     | 148.74     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09776    | 0.09776    | 0.09776    |   0.0 |  0.07
Output  | 0.00021181 | 0.00021181 | 0.00021181 |   0.0 |  0.00
Modify  | 0.33827    | 0.33827    | 0.33827    |   0.0 |  0.23
Other   |            | 0.05867    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.08     | 174.08     | 174.08     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11164    | 0.11164    | 0.11164    |   0.0 |  0.06
Output  | 0.00021279 | 0.00021279 | 0.00021279 |   0.0 |  0.00
Modify  | 0.42204    | 0.42204    | 0.42204    |   0.0 |  0.24
Other   |            | 0.06696    |            |       |  0.04

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

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

Performance: 0.505 ns/day, 47.554 hours/ns, 5.841 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    | 170.61     | 170.61     | 170.61     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.06
Output  | 0.00016878 | 0.00016878 | 0.00016878 |   0.0 |  0.00
Modify  | 0.40678    | 0.40678    | 0.40678    |   0.0 |  0.24
Other   |            | 0.06499    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.48     | 174.48     | 174.48     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11152    | 0.11152    | 0.11152    |   0.0 |  0.06
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.44209    | 0.44209    | 0.44209    |   0.0 |  0.25
Other   |            | 0.06704    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.59     | 174.59     | 174.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11144    | 0.11144    | 0.11144    |   0.0 |  0.06
Output  | 0.00016836 | 0.00016836 | 0.00016836 |   0.0 |  0.00
Modify  | 0.44674    | 0.44674    | 0.44674    |   0.0 |  0.25
Other   |            | 0.06667    |            |       |  0.04

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

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

Performance: 0.490 ns/day, 48.986 hours/ns, 5.671 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.73     | 175.73     | 175.73     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11313    | 0.11313    | 0.11313    |   0.0 |  0.06
Output  | 0.00020907 | 0.00020907 | 0.00020907 |   0.0 |  0.00
Modify  | 0.44529    | 0.44529    | 0.44529    |   0.0 |  0.25
Other   |            | 0.06712    |            |       |  0.04

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

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

Performance: 0.490 ns/day, 49.029 hours/ns, 5.666 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 175.88     | 175.88     | 175.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11148    | 0.11148    | 0.11148    |   0.0 |  0.06
Output  | 0.00016981 | 0.00016981 | 0.00016981 |   0.0 |  0.00
Modify  | 0.44158    | 0.44158    | 0.44158    |   0.0 |  0.25
Other   |            | 0.06714    |            |       |  0.04

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

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

Performance: 0.555 ns/day, 43.234 hours/ns, 6.425 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 155.1      | 155.1      | 155.1      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10234    | 0.10234    | 0.10234    |   0.0 |  0.07
Output  | 0.00020361 | 0.00020361 | 0.00020361 |   0.0 |  0.00
Modify  | 0.38027    | 0.38027    | 0.38027    |   0.0 |  0.24
Other   |            | 0.06096    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4302 ave        4302 max        4302 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264866 ave      264866 max      264866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.81     | 148.81     | 148.81     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097969   | 0.097969   | 0.097969   |   0.0 |  0.07
Output  | 0.00016981 | 0.00016981 | 0.00016981 |   0.0 |  0.00
Modify  | 0.35889    | 0.35889    | 0.35889    |   0.0 |  0.24
Other   |            | 0.05892    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 149.4      | 149.4      | 149.4      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097301   | 0.097301   | 0.097301   |   0.0 |  0.06
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.36186    | 0.36186    | 0.36186    |   0.0 |  0.24
Other   |            | 0.05912    |            |       |  0.04

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

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

Performance: 0.519 ns/day, 46.242 hours/ns, 6.007 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    | 165.88     | 165.88     | 165.88     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10738    | 0.10738    | 0.10738    |   0.0 |  0.06
Output  | 0.00027618 | 0.00027618 | 0.00027618 |   0.0 |  0.00
Modify  | 0.41894    | 0.41894    | 0.41894    |   0.0 |  0.25
Other   |            | 0.06402    |            |       |  0.04

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

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

Performance: 0.539 ns/day, 44.508 hours/ns, 6.241 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 159.66     | 159.66     | 159.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10396    | 0.10396    | 0.10396    |   0.0 |  0.06
Output  | 0.00044952 | 0.00044952 | 0.00044952 |   0.0 |  0.00
Modify  | 0.4005     | 0.4005     | 0.4005     |   0.0 |  0.25
Other   |            | 0.06313    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.78     | 148.78     | 148.78     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099085   | 0.099085   | 0.099085   |   0.0 |  0.07
Output  | 0.0001702  | 0.0001702  | 0.0001702  |   0.0 |  0.00
Modify  | 0.3629     | 0.3629     | 0.3629     |   0.0 |  0.24
Other   |            | 0.05955    |            |       |  0.04

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

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

Performance: 0.496 ns/day, 48.400 hours/ns, 5.739 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    | 173.62     | 173.62     | 173.62     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11036    | 0.11036    | 0.11036    |   0.0 |  0.06
Output  | 0.0002106  | 0.0002106  | 0.0002106  |   0.0 |  0.00
Modify  | 0.44022    | 0.44022    | 0.44022    |   0.0 |  0.25
Other   |            | 0.06627    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4214 ave        4214 max        4214 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264902 ave      264902 max      264902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.531 ns/day, 45.206 hours/ns, 6.145 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 162.17     | 162.17     | 162.17     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10525    | 0.10525    | 0.10525    |   0.0 |  0.06
Output  | 0.00017239 | 0.00017239 | 0.00017239 |   0.0 |  0.00
Modify  | 0.40501    | 0.40501    | 0.40501    |   0.0 |  0.25
Other   |            | 0.06283    |            |       |  0.04

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

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

Performance: 0.497 ns/day, 48.248 hours/ns, 5.757 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.08     | 173.08     | 173.08     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1106     | 0.1106     | 0.1106     |   0.0 |  0.06
Output  | 0.00021406 | 0.00021406 | 0.00021406 |   0.0 |  0.00
Modify  | 0.44074    | 0.44074    | 0.44074    |   0.0 |  0.25
Other   |            | 0.06627    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.38     | 174.38     | 174.38     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11196    | 0.11196    | 0.11196    |   0.0 |  0.06
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.44611    | 0.44611    | 0.44611    |   0.0 |  0.25
Other   |            | 0.06603    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4237 ave        4237 max        4237 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264462 ave      264462 max      264462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.53     | 148.53     | 148.53     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09813    | 0.09813    | 0.09813    |   0.0 |  0.07
Output  | 0.00017446 | 0.00017446 | 0.00017446 |   0.0 |  0.00
Modify  | 0.36056    | 0.36056    | 0.36056    |   0.0 |  0.24
Other   |            | 0.05885    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.41     | 148.41     | 148.41     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098858   | 0.098858   | 0.098858   |   0.0 |  0.07
Output  | 0.0002112  | 0.0002112  | 0.0002112  |   0.0 |  0.00
Modify  | 0.36028    | 0.36028    | 0.36028    |   0.0 |  0.24
Other   |            | 0.05873    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.66     | 148.66     | 148.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098617   | 0.098617   | 0.098617   |   0.0 |  0.07
Output  | 0.00017069 | 0.00017069 | 0.00017069 |   0.0 |  0.00
Modify  | 0.36084    | 0.36084    | 0.36084    |   0.0 |  0.24
Other   |            | 0.05885    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.55     | 148.55     | 148.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096883   | 0.096883   | 0.096883   |   0.0 |  0.06
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.36033    | 0.36033    | 0.36033    |   0.0 |  0.24
Other   |            | 0.05819    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4232 ave        4232 max        4232 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       264756 ave      264756 max      264756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09906    | 0.09906    | 0.09906    |   0.0 |  0.07
Output  | 0.00016874 | 0.00016874 | 0.00016874 |   0.0 |  0.00
Modify  | 0.36136    | 0.36136    | 0.36136    |   0.0 |  0.24
Other   |            | 0.05857    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.75     | 148.75     | 148.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099041   | 0.099041   | 0.099041   |   0.0 |  0.07
Output  | 0.00016967 | 0.00016967 | 0.00016967 |   0.0 |  0.00
Modify  | 0.36022    | 0.36022    | 0.36022    |   0.0 |  0.24
Other   |            | 0.05866    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4289 ave        4289 max        4289 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265106 ave      265106 max      265106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.51     | 148.51     | 148.51     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098328   | 0.098328   | 0.098328   |   0.0 |  0.07
Output  | 0.00017003 | 0.00017003 | 0.00017003 |   0.0 |  0.00
Modify  | 0.36099    | 0.36099    | 0.36099    |   0.0 |  0.24
Other   |            | 0.05891    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.09     | 148.09     | 148.09     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097671   | 0.097671   | 0.097671   |   0.0 |  0.07
Output  | 0.00020426 | 0.00020426 | 0.00020426 |   0.0 |  0.00
Modify  | 0.36084    | 0.36084    | 0.36084    |   0.0 |  0.24
Other   |            | 0.0584     |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.56     | 148.56     | 148.56     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097937   | 0.097937   | 0.097937   |   0.0 |  0.07
Output  | 0.00021019 | 0.00021019 | 0.00021019 |   0.0 |  0.00
Modify  | 0.35989    | 0.35989    | 0.35989    |   0.0 |  0.24
Other   |            | 0.05907    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.7      | 148.7      | 148.7      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09766    | 0.09766    | 0.09766    |   0.0 |  0.07
Output  | 0.00017305 | 0.00017305 | 0.00017305 |   0.0 |  0.00
Modify  | 0.35973    | 0.35973    | 0.35973    |   0.0 |  0.24
Other   |            | 0.05866    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.5      | 148.5      | 148.5      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097495   | 0.097495   | 0.097495   |   0.0 |  0.07
Output  | 0.00020999 | 0.00020999 | 0.00020999 |   0.0 |  0.00
Modify  | 0.36107    | 0.36107    | 0.36107    |   0.0 |  0.24
Other   |            | 0.05886    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4253 ave        4253 max        4253 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265116 ave      265116 max      265116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.59     | 148.59     | 148.59     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099069   | 0.099069   | 0.099069   |   0.0 |  0.07
Output  | 0.00016944 | 0.00016944 | 0.00016944 |   0.0 |  0.00
Modify  | 0.36036    | 0.36036    | 0.36036    |   0.0 |  0.24
Other   |            | 0.05853    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.91     | 148.91     | 148.91     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099725   | 0.099725   | 0.099725   |   0.0 |  0.07
Output  | 0.00016955 | 0.00016955 | 0.00016955 |   0.0 |  0.00
Modify  | 0.36122    | 0.36122    | 0.36122    |   0.0 |  0.24
Other   |            | 0.05854    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.54     | 148.54     | 148.54     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098369   | 0.098369   | 0.098369   |   0.0 |  0.07
Output  | 0.00017153 | 0.00017153 | 0.00017153 |   0.0 |  0.00
Modify  | 0.36043    | 0.36043    | 0.36043    |   0.0 |  0.24
Other   |            | 0.05865    |            |       |  0.04

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.61     | 148.61     | 148.61     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098962   | 0.098962   | 0.098962   |   0.0 |  0.07
Output  | 0.00017154 | 0.00017154 | 0.00017154 |   0.0 |  0.00
Modify  | 0.36134    | 0.36134    | 0.36134    |   0.0 |  0.24
Other   |            | 0.05861    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4229 ave        4229 max        4229 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       265048 ave      265048 max      265048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 148.3      | 148.3      | 148.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097681   | 0.097681   | 0.097681   |   0.0 |  0.07
Output  | 0.00021101 | 0.00021101 | 0.00021101 |   0.0 |  0.00
Modify  | 0.36006    | 0.36006    | 0.36006    |   0.0 |  0.24
Other   |            | 0.05956    |            |       |  0.04

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0