# 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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  -16099.085     -16099.085     -16180         -16180          313.15         313.15         36035.1        36035.1        2398.3751      2398.3751    
      1000  -16019.971     -16019.971     -16104.74      -16104.74       328.06371      328.06371      36384.132      36384.132     -3919.729      -3919.729     
Loop time of 161.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.535 ns/day, 44.847 hours/ns, 6.194 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    | 160.91     | 160.91     | 160.91     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.06
Output  | 0.00021733 | 0.00021733 | 0.00021733 |   0.0 |  0.00
Modify  | 0.37309    | 0.37309    | 0.37309    |   0.0 |  0.23
Other   |            | 0.06333    |            |       |  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.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   
      1000  -16019.971     -16019.971     -16104.74      -16104.74       328.06371      328.06371      36384.132      36384.132     -3919.729      -3919.729     
      2000  -16018.909     -16018.909     -16098.325     -16098.325      307.34984      307.34984      36338.611      36338.611     -354.974       -354.974      
Loop time of 173.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.229 hours/ns, 5.760 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.03     | 173.03     | 173.03     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11215    | 0.11215    | 0.11215    |   0.0 |  0.06
Output  | 0.00024747 | 0.00024747 | 0.00024747 |   0.0 |  0.00
Modify  | 0.41788    | 0.41788    | 0.41788    |   0.0 |  0.24
Other   |            | 0.06632    |            |       |  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:       262806 ave      262806 max      262806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262806
Ave neighs/atom = 131.403
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  -16018.909     -16018.909     -16098.325     -16098.325      307.34984      307.34984      36338.611      36338.611     -354.974       -354.974      
      3000  -16024.14      -16024.14      -16101.026     -16101.026      297.55588      297.55588      36302.11       36302.11       703.67966      703.67966    
Loop time of 148.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.115 hours/ns, 6.756 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    | 147.52     | 147.52     | 147.52     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099236   | 0.099236   | 0.099236   |   0.0 |  0.07
Output  | 0.00021179 | 0.00021179 | 0.00021179 |   0.0 |  0.00
Modify  | 0.33826    | 0.33826    | 0.33826    |   0.0 |  0.23
Other   |            | 0.05932    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4258 ave        4258 max        4258 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:       262840 ave      262840 max      262840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262840
Ave neighs/atom = 131.42
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  -16024.14      -16024.14      -16101.026     -16101.026      297.55588      297.55588      36302.11       36302.11       703.67966      703.67966    
      4000  -16019.695     -16019.695     -16099.814     -16099.814      310.06982      310.06982      36282.874      36282.874      2061.3031      2061.3031    
Loop time of 147.989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.108 hours/ns, 6.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    | 147.49     | 147.49     | 147.49     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09909    | 0.09909    | 0.09909    |   0.0 |  0.07
Output  | 0.00020893 | 0.00020893 | 0.00020893 |   0.0 |  0.00
Modify  | 0.33597    | 0.33597    | 0.33597    |   0.0 |  0.23
Other   |            | 0.05985    |            |       |  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:       263228 ave      263228 max      263228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263228
Ave neighs/atom = 131.614
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  -16019.695     -16019.695     -16099.814     -16099.814      310.06982      310.06982      36282.874      36282.874      2061.3031      2061.3031    
      5000  -16020.046     -16020.046     -16101.551     -16101.551      315.43036      315.43036      36299.351      36299.351      982.52329      982.52329    
Loop time of 147.875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.076 hours/ns, 6.762 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    | 147.38     | 147.38     | 147.38     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099359   | 0.099359   | 0.099359   |   0.0 |  0.07
Output  | 0.00016774 | 0.00016774 | 0.00016774 |   0.0 |  0.00
Modify  | 0.3391     | 0.3391     | 0.3391     |   0.0 |  0.23
Other   |            | 0.05874    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4279 ave        4279 max        4279 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:       263458 ave      263458 max      263458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263458
Ave neighs/atom = 131.729
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 = 315.109240784699, Press = -598.463076760425
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  -16020.046     -16020.046     -16101.551     -16101.551      315.43036      315.43036      36299.351      36299.351      982.52329      982.52329    
      6000  -16020.774     -16020.774     -16100.648     -16100.648      309.1203       309.1203       36314.764      36314.764      286.41993      286.41993    
Loop time of 148.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.583 ns/day, 41.186 hours/ns, 6.745 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    | 147.75     | 147.75     | 147.75     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098901   | 0.098901   | 0.098901   |   0.0 |  0.07
Output  | 0.00016835 | 0.00016835 | 0.00016835 |   0.0 |  0.00
Modify  | 0.35732    | 0.35732    | 0.35732    |   0.0 |  0.24
Other   |            | 0.05879    |            |       |  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:       263494 ave      263494 max      263494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263494
Ave neighs/atom = 131.747
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 = 312.772956022645, Press = -14.3739879028827
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  -16020.774     -16020.774     -16100.648     -16100.648      309.1203       309.1203       36314.764      36314.764      286.41993      286.41993    
      7000  -16017.297     -16017.297     -16100.762     -16100.762      323.01824      323.01824      36314.867      36314.867      426.23132      426.23132    
Loop time of 147.714 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.032 hours/ns, 6.770 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    | 147.2      | 147.2      | 147.2      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098737   | 0.098737   | 0.098737   |   0.0 |  0.07
Output  | 0.0001666  | 0.0001666  | 0.0001666  |   0.0 |  0.00
Modify  | 0.35645    | 0.35645    | 0.35645    |   0.0 |  0.24
Other   |            | 0.05916    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4278 ave        4278 max        4278 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:       263190 ave      263190 max      263190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263190
Ave neighs/atom = 131.595
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 = 313.173678143781, Press = -49.2394163396321
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  -16017.297     -16017.297     -16100.762     -16100.762      323.01824      323.01824      36314.867      36314.867      426.23132      426.23132    
      8000  -16021.464     -16021.464     -16102         -16102          311.67946      311.67946      36329.157      36329.157     -531.66928     -531.66928    
Loop time of 148.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.582 ns/day, 41.264 hours/ns, 6.732 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.03     | 148.03     | 148.03     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10052    | 0.10052    | 0.10052    |   0.0 |  0.07
Output  | 0.00016882 | 0.00016882 | 0.00016882 |   0.0 |  0.00
Modify  | 0.35978    | 0.35978    | 0.35978    |   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:           4280 ave        4280 max        4280 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:       263300 ave      263300 max      263300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263300
Ave neighs/atom = 131.65
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 = 314.041657635848, Press = -13.3392703851379
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  -16021.464     -16021.464     -16102         -16102          311.67946      311.67946      36329.157      36329.157     -531.66928     -531.66928    
      9000  -16017.591     -16017.591     -16097.88      -16097.88       310.72804      310.72804      36260.47       36260.47       3442.0383      3442.0383    
Loop time of 147.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.074 hours/ns, 6.763 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    | 147.35     | 147.35     | 147.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099927   | 0.099927   | 0.099927   |   0.0 |  0.07
Output  | 0.00016864 | 0.00016864 | 0.00016864 |   0.0 |  0.00
Modify  | 0.3593     | 0.3593     | 0.3593     |   0.0 |  0.24
Other   |            | 0.05916    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4288 ave        4288 max        4288 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:       263106 ave      263106 max      263106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263106
Ave neighs/atom = 131.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 = 314.271392113273, Press = -4.92367597178119
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   
      9000  -16017.591     -16017.591     -16097.88      -16097.88       310.72804      310.72804      36260.47       36260.47       3442.0383      3442.0383    
     10000  -16020.857     -16020.857     -16102.855     -16102.855      317.34086      317.34086      36365.179      36365.179     -2581.8972     -2581.8972    
Loop time of 149.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.578 ns/day, 41.498 hours/ns, 6.694 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.87     | 148.87     | 148.87     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10048    | 0.10048    | 0.10048    |   0.0 |  0.07
Output  | 0.00020962 | 0.00020962 | 0.00020962 |   0.0 |  0.00
Modify  | 0.36119    | 0.36119    | 0.36119    |   0.0 |  0.24
Other   |            | 0.05952    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4290 ave        4290 max        4290 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:       263488 ave      263488 max      263488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263488
Ave neighs/atom = 131.744
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 = 313.804979694824, Press = -9.10369986045124
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  -16020.857     -16020.857     -16102.855     -16102.855      317.34086      317.34086      36365.179      36365.179     -2581.8972     -2581.8972    
     11000  -16020.726     -16020.726     -16100.784     -16100.784      309.83096      309.83096      36337.38       36337.38      -880.1498      -880.1498     
Loop time of 171.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.679 hours/ns, 5.826 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    | 171.03     | 171.03     | 171.03     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11129    | 0.11129    | 0.11129    |   0.0 |  0.06
Output  | 0.00016901 | 0.00016901 | 0.00016901 |   0.0 |  0.00
Modify  | 0.43504    | 0.43504    | 0.43504    |   0.0 |  0.25
Other   |            | 0.06632    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4246 ave        4246 max        4246 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:       262786 ave      262786 max      262786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262786
Ave neighs/atom = 131.393
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 = 313.885815662206, Press = 5.00803256961987
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  -16020.726     -16020.726     -16100.784     -16100.784      309.83096      309.83096      36337.38       36337.38      -880.1498      -880.1498     
     12000  -16019.396     -16019.396     -16100.529     -16100.529      313.99151      313.99151      36299.465      36299.465      1205.5964      1205.5964    
Loop time of 147.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.047 hours/ns, 6.767 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    | 147.25     | 147.25     | 147.25     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099033   | 0.099033   | 0.099033   |   0.0 |  0.07
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.35691    | 0.35691    | 0.35691    |   0.0 |  0.24
Other   |            | 0.05917    |            |       |  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:       262930 ave      262930 max      262930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262930
Ave neighs/atom = 131.465
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 = 313.891963297574, Press = -7.2730445971389
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   
     12000  -16019.396     -16019.396     -16100.529     -16100.529      313.99151      313.99151      36299.465      36299.465      1205.5964      1205.5964    
     13000  -16017.954     -16017.954     -16100.987     -16100.987      321.34704      321.34704      36306.184      36306.184      723.05467      723.05467    
Loop time of 148.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.130 hours/ns, 6.754 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    | 147.55     | 147.55     | 147.55     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1        | 0.1        | 0.1        |   0.0 |  0.07
Output  | 0.00016886 | 0.00016886 | 0.00016886 |   0.0 |  0.00
Modify  | 0.35734    | 0.35734    | 0.35734    |   0.0 |  0.24
Other   |            | 0.05962    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4307 ave        4307 max        4307 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:       263146 ave      263146 max      263146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263146
Ave neighs/atom = 131.573
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 = 313.99164292573, Press = -0.28460211486567
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  -16017.954     -16017.954     -16100.987     -16100.987      321.34704      321.34704      36306.184      36306.184      723.05467      723.05467    
     14000  -16023.575     -16023.575     -16101.845     -16101.845      302.91376      302.91376      36344.879      36344.879     -1449.3918     -1449.3918    
Loop time of 157.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.549 ns/day, 43.749 hours/ns, 6.349 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    | 156.94     | 156.94     | 156.94     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10464    | 0.10464    | 0.10464    |   0.0 |  0.07
Output  | 0.0002042  | 0.0002042  | 0.0002042  |   0.0 |  0.00
Modify  | 0.39067    | 0.39067    | 0.39067    |   0.0 |  0.25
Other   |            | 0.06236    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4282 ave        4282 max        4282 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:       263222 ave      263222 max      263222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263222
Ave neighs/atom = 131.611
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 = 313.96824764287, Press = -2.11478014874212
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  -16023.575     -16023.575     -16101.845     -16101.845      302.91376      302.91376      36344.879      36344.879     -1449.3918     -1449.3918    
     15000  -16020.59      -16020.59      -16101.11      -16101.11       311.61962      311.61962      36326.319      36326.319     -313.83998     -313.83998    
Loop time of 162.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.530 ns/day, 45.277 hours/ns, 6.135 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.42     | 162.42     | 162.42     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10738    | 0.10738    | 0.10738    |   0.0 |  0.07
Output  | 0.00020849 | 0.00020849 | 0.00020849 |   0.0 |  0.00
Modify  | 0.40817    | 0.40817    | 0.40817    |   0.0 |  0.25
Other   |            | 0.06344    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4246 ave        4246 max        4246 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:       262958 ave      262958 max      262958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262958
Ave neighs/atom = 131.479
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 = 313.783050688123, Press = 0.316187822915181
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  -16020.59      -16020.59      -16101.11      -16101.11       311.61962      311.61962      36326.319      36326.319     -313.83998     -313.83998    
     16000  -16022.661     -16022.661     -16102.337     -16102.337      308.35117      308.35117      36326.688      36326.688     -702.98086     -702.98086    
Loop time of 148.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.581 ns/day, 41.338 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.099082   | 0.099082   | 0.099082   |   0.0 |  0.07
Output  | 0.0002303  | 0.0002303  | 0.0002303  |   0.0 |  0.00
Modify  | 0.36089    | 0.36089    | 0.36089    |   0.0 |  0.24
Other   |            | 0.05952    |            |       |  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:       263020 ave      263020 max      263020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263020
Ave neighs/atom = 131.51
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 = 313.657059454697, Press = -3.55027902093506
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  -16022.661     -16022.661     -16102.337     -16102.337      308.35117      308.35117      36326.688      36326.688     -702.98086     -702.98086    
     17000  -16022.362     -16022.362     -16101.584     -16101.584      306.59848      306.59848      36339.933      36339.933     -1370.3944     -1370.3944    
Loop time of 173.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.497 ns/day, 48.250 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.11259    | 0.11259    | 0.11259    |   0.0 |  0.06
Output  | 0.0002147  | 0.0002147  | 0.0002147  |   0.0 |  0.00
Modify  | 0.44268    | 0.44268    | 0.44268    |   0.0 |  0.25
Other   |            | 0.06742    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4279 ave        4279 max        4279 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:       263284 ave      263284 max      263284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263284
Ave neighs/atom = 131.642
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 = 313.562492789502, Press = 2.37111305500125
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  -16022.362     -16022.362     -16101.584     -16101.584      306.59848      306.59848      36339.933      36339.933     -1370.3944     -1370.3944    
     18000  -16021.486     -16021.486     -16102.148     -16102.148      312.17083      312.17083      36341.616      36341.616     -1419.9798     -1419.9798    
Loop time of 173.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.206 hours/ns, 5.762 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    | 172.92     | 172.92     | 172.92     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11185    | 0.11185    | 0.11185    |   0.0 |  0.06
Output  | 0.00016765 | 0.00016765 | 0.00016765 |   0.0 |  0.00
Modify  | 0.44171    | 0.44171    | 0.44171    |   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:           4244 ave        4244 max        4244 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:       263000 ave      263000 max      263000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263000
Ave neighs/atom = 131.5
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 = 313.300187572034, Press = -3.68004984572113
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   
     18000  -16021.486     -16021.486     -16102.148     -16102.148      312.17083      312.17083      36341.616      36341.616     -1419.9798     -1419.9798    
     19000  -16018.065     -16018.065     -16100.407     -16100.407      318.67118      318.67118      36322.744      36322.744     -131.83048     -131.83048    
Loop time of 173.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.091 hours/ns, 5.776 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    | 172.5      | 172.5      | 172.5      |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11399    | 0.11399    | 0.11399    |   0.0 |  0.07
Output  | 0.00026457 | 0.00026457 | 0.00026457 |   0.0 |  0.00
Modify  | 0.44261    | 0.44261    | 0.44261    |   0.0 |  0.26
Other   |            | 0.06849    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4305 ave        4305 max        4305 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:       262582 ave      262582 max      262582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262582
Ave neighs/atom = 131.291
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 = 313.211266744328, Press = 0.540559588449605
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  -16018.065     -16018.065     -16100.407     -16100.407      318.67118      318.67118      36322.744      36322.744     -131.83048     -131.83048    
     20000  -16022.693     -16022.693     -16102.41      -16102.41       308.51248      308.51248      36338.933      36338.933     -1150.4492     -1150.4492    
Loop time of 168.343 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.513 ns/day, 46.762 hours/ns, 5.940 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    | 167.74     | 167.74     | 167.74     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10978    | 0.10978    | 0.10978    |   0.0 |  0.07
Output  | 0.00028083 | 0.00028083 | 0.00028083 |   0.0 |  0.00
Modify  | 0.42582    | 0.42582    | 0.42582    |   0.0 |  0.25
Other   |            | 0.0653     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4282 ave        4282 max        4282 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:       263044 ave      263044 max      263044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263044
Ave neighs/atom = 131.522
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 = 313.336091238204, Press = -4.0365608620532
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  -16022.693     -16022.693     -16102.41      -16102.41       308.51248      308.51248      36338.933      36338.933     -1150.4492     -1150.4492    
     21000  -16020.192     -16020.192     -16101.994     -16101.994      316.58127      316.58127      36344.823      36344.823     -1322.0657     -1322.0657    
Loop time of 172.43 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.501 ns/day, 47.897 hours/ns, 5.799 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    | 171.81     | 171.81     | 171.81     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11134    | 0.11134    | 0.11134    |   0.0 |  0.06
Output  | 0.00021277 | 0.00021277 | 0.00021277 |   0.0 |  0.00
Modify  | 0.438      | 0.438      | 0.438      |   0.0 |  0.25
Other   |            | 0.06615    |            |       |  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:       262998 ave      262998 max      262998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262998
Ave neighs/atom = 131.499
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 = 313.391046443146, Press = -1.2976212371718
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  -16020.192     -16020.192     -16101.994     -16101.994      316.58127      316.58127      36344.823      36344.823     -1322.0657     -1322.0657    
     22000  -16020.938     -16020.938     -16103.148     -16103.148      318.16191      318.16191      36267.72       36267.72       2379.1292      2379.1292    
Loop time of 174.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.393 hours/ns, 5.740 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.59     | 173.59     | 173.59     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11276    | 0.11276    | 0.11276    |   0.0 |  0.06
Output  | 0.00017135 | 0.00017135 | 0.00017135 |   0.0 |  0.00
Modify  | 0.44165    | 0.44165    | 0.44165    |   0.0 |  0.25
Other   |            | 0.06626    |            |       |  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:       262800 ave      262800 max      262800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262800
Ave neighs/atom = 131.4
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 = 313.316108565614, Press = 1.22833785483095
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   
     22000  -16020.938     -16020.938     -16103.148     -16103.148      318.16191      318.16191      36267.72       36267.72       2379.1292      2379.1292    
     23000  -16020.603     -16020.603     -16100.834     -16100.834      310.50241      310.50241      36343.412      36343.412     -1159.2564     -1159.2564    
Loop time of 157.215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.550 ns/day, 43.671 hours/ns, 6.361 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    | 156.66     | 156.66     | 156.66     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10368    | 0.10368    | 0.10368    |   0.0 |  0.07
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.38802    | 0.38802    | 0.38802    |   0.0 |  0.25
Other   |            | 0.06134    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4296 ave        4296 max        4296 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:       263668 ave      263668 max      263668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263668
Ave neighs/atom = 131.834
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 = 313.308062726943, Press = -4.41790141362052
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  -16020.603     -16020.603     -16100.834     -16100.834      310.50241      310.50241      36343.412      36343.412     -1159.2564     -1159.2564    
     24000  -16025.151     -16025.151     -16104.588     -16104.588      307.42886      307.42886      36335.893      36335.893     -1317.9996     -1317.9996    
Loop time of 147.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.059 hours/ns, 6.765 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    | 147.3      | 147.3      | 147.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099245   | 0.099245   | 0.099245   |   0.0 |  0.07
Output  | 0.00016983 | 0.00016983 | 0.00016983 |   0.0 |  0.00
Modify  | 0.35758    | 0.35758    | 0.35758    |   0.0 |  0.24
Other   |            | 0.05877    |            |       |  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:       262760 ave      262760 max      262760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262760
Ave neighs/atom = 131.38
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 = 313.271194611651, Press = -2.56283799625241
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  -16025.151     -16025.151     -16104.588     -16104.588      307.42886      307.42886      36335.893      36335.893     -1317.9996     -1317.9996    
     25000  -16019.458     -16019.458     -16098.842     -16098.842      307.22522      307.22522      36364.677      36364.677     -1989.4486     -1989.4486    
Loop time of 151.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.569 ns/day, 42.189 hours/ns, 6.584 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    | 151.35     | 151.35     | 151.35     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10138    | 0.10138    | 0.10138    |   0.0 |  0.07
Output  | 0.00021233 | 0.00021233 | 0.00021233 |   0.0 |  0.00
Modify  | 0.36967    | 0.36967    | 0.36967    |   0.0 |  0.24
Other   |            | 0.05946    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4246 ave        4246 max        4246 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:       263304 ave      263304 max      263304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263304
Ave neighs/atom = 131.652
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 = 313.173048921175, Press = -1.15419595459868
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  -16019.458     -16019.458     -16098.842     -16098.842      307.22522      307.22522      36364.677      36364.677     -1989.4486     -1989.4486    
     26000  -16019.142     -16019.142     -16100.044     -16100.044      313.098        313.098        36377.976      36377.976     -2552.9908     -2552.9908    
Loop time of 161.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.534 ns/day, 44.965 hours/ns, 6.178 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    | 161.3      | 161.3      | 161.3      |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10579    | 0.10579    | 0.10579    |   0.0 |  0.07
Output  | 0.00020657 | 0.00020657 | 0.00020657 |   0.0 |  0.00
Modify  | 0.40231    | 0.40231    | 0.40231    |   0.0 |  0.25
Other   |            | 0.06245    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4233 ave        4233 max        4233 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:       262606 ave      262606 max      262606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262606
Ave neighs/atom = 131.303
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 = 313.081636276977, Press = -4.28278675883642
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  -16019.142     -16019.142     -16100.044     -16100.044      313.098        313.098        36377.976      36377.976     -2552.9908     -2552.9908    
     27000  -16026.429     -16026.429     -16106.323     -16106.323      309.19884      309.19884      36333.185      36333.185     -1635.4454     -1635.4454    
Loop time of 147.273 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.909 hours/ns, 6.790 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    | 146.76     | 146.76     | 146.76     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098725   | 0.098725   | 0.098725   |   0.0 |  0.07
Output  | 0.00020867 | 0.00020867 | 0.00020867 |   0.0 |  0.00
Modify  | 0.35749    | 0.35749    | 0.35749    |   0.0 |  0.24
Other   |            | 0.05941    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4256 ave        4256 max        4256 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:       262490 ave      262490 max      262490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262490
Ave neighs/atom = 131.245
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 = 313.043466172653, Press = -0.306994771194018
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  -16026.429     -16026.429     -16106.323     -16106.323      309.19884      309.19884      36333.185      36333.185     -1635.4454     -1635.4454    
     28000  -16020.234     -16020.234     -16101.599     -16101.599      314.89044      314.89044      36317.448      36317.448      71.31489       71.31489     
Loop time of 147.96 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.100 hours/ns, 6.759 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    | 147.44     | 147.44     | 147.44     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098956   | 0.098956   | 0.098956   |   0.0 |  0.07
Output  | 0.00022053 | 0.00022053 | 0.00022053 |   0.0 |  0.00
Modify  | 0.35842    | 0.35842    | 0.35842    |   0.0 |  0.24
Other   |            | 0.06062    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4281 ave        4281 max        4281 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:       263468 ave      263468 max      263468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263468
Ave neighs/atom = 131.734
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 = 312.952127131169, Press = -1.43097011714246
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   
     28000  -16020.234     -16020.234     -16101.599     -16101.599      314.89044      314.89044      36317.448      36317.448      71.31489       71.31489     
     29000  -16019.258     -16019.258     -16101.265     -16101.265      317.37478      317.37478      36337.255      36337.255     -780.51949     -780.51949    
Loop time of 147.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 40.995 hours/ns, 6.776 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    | 147.06     | 147.06     | 147.06     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099738   | 0.099738   | 0.099738   |   0.0 |  0.07
Output  | 0.00016879 | 0.00016879 | 0.00016879 |   0.0 |  0.00
Modify  | 0.3583     | 0.3583     | 0.3583     |   0.0 |  0.24
Other   |            | 0.05939    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4299 ave        4299 max        4299 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:       263002 ave      263002 max      263002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263002
Ave neighs/atom = 131.501
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 = 312.97903112548, Press = -1.12276109799071
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   
     29000  -16019.258     -16019.258     -16101.265     -16101.265      317.37478      317.37478      36337.255      36337.255     -780.51949     -780.51949    
     30000  -16020.406     -16020.406     -16100.295     -16100.295      309.17857      309.17857      36325.884      36325.884     -315.7383      -315.7383     
Loop time of 147.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.585 ns/day, 41.046 hours/ns, 6.768 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    | 147.25     | 147.25     | 147.25     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10005    | 0.10005    | 0.10005    |   0.0 |  0.07
Output  | 0.00016871 | 0.00016871 | 0.00016871 |   0.0 |  0.00
Modify  | 0.35895    | 0.35895    | 0.35895    |   0.0 |  0.24
Other   |            | 0.05905    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4305 ave        4305 max        4305 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:       262964 ave      262964 max      262964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262964
Ave neighs/atom = 131.482
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 = 312.999961469465, Press = -1.4608006628741
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  -16020.406     -16020.406     -16100.295     -16100.295      309.17857      309.17857      36325.884      36325.884     -315.7383      -315.7383     
     31000  -16018.85      -16018.85      -16101.996     -16101.996      321.78359      321.78359      36336.927      36336.927     -868.36968     -868.36968    
Loop time of 147.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.584 ns/day, 41.067 hours/ns, 6.764 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    | 147.33     | 147.33     | 147.33     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099618   | 0.099618   | 0.099618   |   0.0 |  0.07
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.35841    | 0.35841    | 0.35841    |   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:           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:       263082 ave      263082 max      263082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263082
Ave neighs/atom = 131.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 = 313.0144058251, Press = 1.22314162462289
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  -16018.85      -16018.85      -16101.996     -16101.996      321.78359      321.78359      36336.927      36336.927     -868.36968     -868.36968    
     32000  -16018.045     -16018.045     -16101.314     -16101.314      322.25989      322.25989      36301.976      36301.976      756.6319       756.6319     
Loop time of 173.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.160 hours/ns, 5.768 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    | 172.75     | 172.75     | 172.75     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11413    | 0.11413    | 0.11413    |   0.0 |  0.07
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.44132    | 0.44132    | 0.44132    |   0.0 |  0.25
Other   |            | 0.06775    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4285 ave        4285 max        4285 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:       263048 ave      263048 max      263048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263048
Ave neighs/atom = 131.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 = 313.101820282587, Press = -1.02738777431194
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   
     32000  -16018.045     -16018.045     -16101.314     -16101.314      322.25989      322.25989      36301.976      36301.976      756.6319       756.6319     
     33000  -16018.947     -16018.947     -16100.497     -16100.497      315.60862      315.60862      36351.647      36351.647     -1511.8834     -1511.8834    
Loop time of 169.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.978 hours/ns, 5.913 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    | 168.52     | 168.52     | 168.52     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11177    | 0.11177    | 0.11177    |   0.0 |  0.07
Output  | 0.00017013 | 0.00017013 | 0.00017013 |   0.0 |  0.00
Modify  | 0.42689    | 0.42689    | 0.42689    |   0.0 |  0.25
Other   |            | 0.06504    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4326 ave        4326 max        4326 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:       263304 ave      263304 max      263304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263304
Ave neighs/atom = 131.652
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 = 313.122088197504, Press = -1.09569899756254
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  -16018.947     -16018.947     -16100.497     -16100.497      315.60862      315.60862      36351.647      36351.647     -1511.8834     -1511.8834    
     34000  -16021.589     -16021.589     -16100.486     -16100.486      305.33966      305.33966      36286.702      36286.702      1717.1316      1717.1316    
Loop time of 173.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.193 hours/ns, 5.764 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    | 172.87     | 172.87     | 172.87     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11368    | 0.11368    | 0.11368    |   0.0 |  0.07
Output  | 0.00021423 | 0.00021423 | 0.00021423 |   0.0 |  0.00
Modify  | 0.44353    | 0.44353    | 0.44353    |   0.0 |  0.26
Other   |            | 0.06784    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4288 ave        4288 max        4288 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:       262954 ave      262954 max      262954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 262954
Ave neighs/atom = 131.477
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 = 313.199760163658, Press = 0.366515878923293
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  -16021.589     -16021.589     -16100.486     -16100.486      305.33966      305.33966      36286.702      36286.702      1717.1316      1717.1316    
     35000  -16020.097     -16020.097     -16099.378     -16099.378      306.82754      306.82754      36310.605      36310.605      837.48207      837.48207    
Loop time of 166.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.520 ns/day, 46.132 hours/ns, 6.021 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    | 165.48     | 165.48     | 165.48     |   0.0 | 99.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10937    | 0.10937    | 0.10937    |   0.0 |  0.07
Output  | 0.00017006 | 0.00017006 | 0.00017006 |   0.0 |  0.00
Modify  | 0.41864    | 0.41864    | 0.41864    |   0.0 |  0.25
Other   |            | 0.06614    |            |       |  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:       263234 ave      263234 max      263234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263234
Ave neighs/atom = 131.617
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 = 313.224228766877, Press = -1.14245399117498
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   
     35000  -16020.097     -16020.097     -16099.378     -16099.378      306.82754      306.82754      36310.605      36310.605      837.48207      837.48207    
     36000  -16018.464     -16018.464     -16100.95      -16100.95       319.2294       319.2294       36301.594      36301.594      856.70703      856.70703    
Loop time of 147.195 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.587 ns/day, 40.888 hours/ns, 6.794 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    | 146.68     | 146.68     | 146.68     |   0.0 | 99.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099096   | 0.099096   | 0.099096   |   0.0 |  0.07
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.35768    | 0.35768    | 0.35768    |   0.0 |  0.24
Other   |            | 0.06065    |            |       |  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:       263236 ave      263236 max      263236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 263236
Ave neighs/atom = 131.618
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
36318.9183531294

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0