# 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.302343912422657*${_u_distance}
variable latticeconst_converted equal 3.302343912422657*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30234391242266
Lattice spacing in x,y,z = 3.3023439 3.3023439 3.3023439
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (33.023439 33.023439 33.023439)
  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.023439 33.023439 33.023439)
  create_atoms CPU = 0.000 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_HuangLiuDuan_2021_HfNbTaTiZr__MO_893505888031_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 36013.6300215875    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36013.6300215875/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 36013.6300215875/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 36013.6300215875/(1*1*${_u_distance})
variable      V0_metal equal 36013.6300215875/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 36013.6300215875*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36013.6300215875 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_893505888031_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -16102.65      -16102.65      -16183.565     -16183.565      313.15         313.15         36013.63       36013.63       2399.8456      2399.8456    
      1000  -16017.796     -16017.796     -16089.984     -16089.984      279.37505      279.37505      36101.773      36101.773      6283.5672      6283.5672    
Loop time of 90.7517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.952 ns/day, 25.209 hours/ns, 11.019 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 90.67      | 90.67      | 90.67      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015479   | 0.015479   | 0.015479   |   0.0 |  0.02
Output  | 0.00014883 | 0.00014883 | 0.00014883 |   0.0 |  0.00
Modify  | 0.060432   | 0.060432   | 0.060432   |   0.0 |  0.07
Other   |            | 0.005505   |            |       |  0.01

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:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -16017.796     -16017.796     -16089.984     -16089.984      279.37505      279.37505      36101.773      36101.773      6283.5672      6283.5672    
      2000  -16017.178     -16017.178     -16101.156     -16101.156      325.00543      325.00543      36219.053      36219.053     -1061.7741     -1061.7741    
Loop time of 95.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.906 ns/day, 26.482 hours/ns, 10.489 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.255     | 95.255     | 95.255     |   0.0 | 99.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015053   | 0.015053   | 0.015053   |   0.0 |  0.02
Output  | 3.7871e-05 | 3.7871e-05 | 3.7871e-05 |   0.0 |  0.00
Modify  | 0.059463   | 0.059463   | 0.059463   |   0.0 |  0.06
Other   |            | 0.005289   |            |       |  0.01

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:       128964 ave      128964 max      128964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128964
Ave neighs/atom = 64.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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -16017.178     -16017.178     -16101.156     -16101.156      325.00543      325.00543      36219.053      36219.053     -1061.7741     -1061.7741    
      3000  -16020.831     -16020.831     -16103.855     -16103.855      321.31119      321.31119      36172.21       36172.21       1218.2757      1218.2757    
Loop time of 95.4962 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.527 hours/ns, 10.472 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.416     | 95.416     | 95.416     |   0.0 | 99.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015153   | 0.015153   | 0.015153   |   0.0 |  0.02
Output  | 3.722e-05  | 3.722e-05  | 3.722e-05  |   0.0 |  0.00
Modify  | 0.059405   | 0.059405   | 0.059405   |   0.0 |  0.06
Other   |            | 0.005257   |            |       |  0.01

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:       128568 ave      128568 max      128568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128568
Ave neighs/atom = 64.284
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -16020.831     -16020.831     -16103.855     -16103.855      321.31119      321.31119      36172.21       36172.21       1218.2757      1218.2757    
      4000  -16021.227     -16021.227     -16097.726     -16097.726      296.06159      296.06159      36179.087      36179.087      1271.725       1271.725     
Loop time of 95.6088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.558 hours/ns, 10.459 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.529     | 95.529     | 95.529     |   0.0 | 99.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015177   | 0.015177   | 0.015177   |   0.0 |  0.02
Output  | 4.0266e-05 | 4.0266e-05 | 4.0266e-05 |   0.0 |  0.00
Modify  | 0.059461   | 0.059461   | 0.059461   |   0.0 |  0.06
Other   |            | 0.00525    |            |       |  0.01

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:       128582 ave      128582 max      128582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128582
Ave neighs/atom = 64.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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -16021.227     -16021.227     -16097.726     -16097.726      296.06159      296.06159      36179.087      36179.087      1271.725       1271.725     
      5000  -16020.117     -16020.117     -16096.988     -16096.988      297.49726      297.49726      36221.832      36221.832     -1218.2761     -1218.2761    
Loop time of 95.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.631 hours/ns, 10.430 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.793     | 95.793     | 95.793     |   0.0 | 99.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015129   | 0.015129   | 0.015129   |   0.0 |  0.02
Output  | 2.9335e-05 | 2.9335e-05 | 2.9335e-05 |   0.0 |  0.00
Modify  | 0.059625   | 0.059625   | 0.059625   |   0.0 |  0.06
Other   |            | 0.005272   |            |       |  0.01

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:       128912 ave      128912 max      128912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128912
Ave neighs/atom = 64.456
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 = 318.139534823164, Press = 85.5325965744248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -16020.117     -16020.117     -16096.988     -16096.988      297.49726      297.49726      36221.832      36221.832     -1218.2761     -1218.2761    
      6000  -16020.437     -16020.437     -16098.253     -16098.253      301.15484      301.15484      36242.802      36242.802     -2124.476      -2124.476     
Loop time of 95.8937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.637 hours/ns, 10.428 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.811     | 95.811     | 95.811     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015101   | 0.015101   | 0.015101   |   0.0 |  0.02
Output  | 3.0227e-05 | 3.0227e-05 | 3.0227e-05 |   0.0 |  0.00
Modify  | 0.061891   | 0.061891   | 0.061891   |   0.0 |  0.06
Other   |            | 0.005329   |            |       |  0.01

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:       128706 ave      128706 max      128706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128706
Ave neighs/atom = 64.353
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.232307933628, Press = -5.57890162960846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -16020.437     -16020.437     -16098.253     -16098.253      301.15484      301.15484      36242.802      36242.802     -2124.476      -2124.476     
      7000  -16021.327     -16021.327     -16097.131     -16097.131      293.36944      293.36944      36202.415      36202.415      93.937812      93.937812    
Loop time of 95.7923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.609 hours/ns, 10.439 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.71      | 95.71      | 95.71      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015086   | 0.015086   | 0.015086   |   0.0 |  0.02
Output  | 3.0949e-05 | 3.0949e-05 | 3.0949e-05 |   0.0 |  0.00
Modify  | 0.061753   | 0.061753   | 0.061753   |   0.0 |  0.06
Other   |            | 0.005336   |            |       |  0.01

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:       128660 ave      128660 max      128660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128660
Ave neighs/atom = 64.33
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.293413642174, Press = 45.3228779392675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -16021.327     -16021.327     -16097.131     -16097.131      293.36944      293.36944      36202.415      36202.415      93.937812      93.937812    
      8000  -16019.513     -16019.513     -16104.101     -16104.101      327.36176      327.36176      36224.619      36224.619     -1591.4081     -1591.4081    
Loop time of 95.7889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.608 hours/ns, 10.440 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.706     | 95.706     | 95.706     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015261   | 0.015261   | 0.015261   |   0.0 |  0.02
Output  | 3.0848e-05 | 3.0848e-05 | 3.0848e-05 |   0.0 |  0.00
Modify  | 0.061845   | 0.061845   | 0.061845   |   0.0 |  0.06
Other   |            | 0.005326   |            |       |  0.01

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:       128644 ave      128644 max      128644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128644
Ave neighs/atom = 64.322
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.116081535723, Press = 11.7204538937824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -16019.513     -16019.513     -16104.101     -16104.101      327.36176      327.36176      36224.619      36224.619     -1591.4081     -1591.4081    
      9000  -16021.964     -16021.964     -16098.699     -16098.699      296.96879      296.96879      36186.203      36186.203      849.63336      849.63336    
Loop time of 95.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.611 hours/ns, 10.439 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.716     | 95.716     | 95.716     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015172   | 0.015172   | 0.015172   |   0.0 |  0.02
Output  | 3.0037e-05 | 3.0037e-05 | 3.0037e-05 |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.06
Other   |            | 0.005327   |            |       |  0.01

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:       128482 ave      128482 max      128482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128482
Ave neighs/atom = 64.241
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.880950110846, Press = 19.2380697678116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -16021.964     -16021.964     -16098.699     -16098.699      296.96879      296.96879      36186.203      36186.203      849.63336      849.63336    
     10000  -16018.932     -16018.932     -16102.734     -16102.734      324.32519      324.32519      36213.366      36213.366     -789.13868     -789.13868    
Loop time of 95.7285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.591 hours/ns, 10.446 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.646     | 95.646     | 95.646     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015191   | 0.015191   | 0.015191   |   0.0 |  0.02
Output  | 2.9576e-05 | 2.9576e-05 | 2.9576e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.06
Other   |            | 0.005302   |            |       |  0.01

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:       128622 ave      128622 max      128622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128622
Ave neighs/atom = 64.311
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.808557612226, Press = 6.92622452981174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -16018.932     -16018.932     -16102.734     -16102.734      324.32519      324.32519      36213.366      36213.366     -789.13868     -789.13868    
     11000  -16016.355     -16016.355     -16098.749     -16098.749      318.87293      318.87293      36189.815      36189.815      923.94762      923.94762    
Loop time of 95.6101 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.558 hours/ns, 10.459 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.528     | 95.528     | 95.528     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015152   | 0.015152   | 0.015152   |   0.0 |  0.02
Output  | 2.9756e-05 | 2.9756e-05 | 2.9756e-05 |   0.0 |  0.00
Modify  | 0.061817   | 0.061817   | 0.061817   |   0.0 |  0.06
Other   |            | 0.005333   |            |       |  0.01

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:       128514 ave      128514 max      128514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128514
Ave neighs/atom = 64.257
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.077276521368, Press = 0.389627778234395
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -16016.355     -16016.355     -16098.749     -16098.749      318.87293      318.87293      36189.815      36189.815      923.94762      923.94762    
     12000  -16019.886     -16019.886     -16098.601     -16098.601      304.63814      304.63814      36157.917      36157.917      2368.7917      2368.7917    
Loop time of 95.8352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.621 hours/ns, 10.435 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.753     | 95.753     | 95.753     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015126   | 0.015126   | 0.015126   |   0.0 |  0.02
Output  | 2.9736e-05 | 2.9736e-05 | 2.9736e-05 |   0.0 |  0.00
Modify  | 0.061777   | 0.061777   | 0.061777   |   0.0 |  0.06
Other   |            | 0.00529    |            |       |  0.01

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:       128684 ave      128684 max      128684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128684
Ave neighs/atom = 64.342
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.960883343491, Press = 9.65041541809799
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -16019.886     -16019.886     -16098.601     -16098.601      304.63814      304.63814      36157.917      36157.917      2368.7917      2368.7917    
     13000  -16018.491     -16018.491     -16099.776     -16099.776      314.57977      314.57977      36193.366      36193.366      588.2221       588.2221     
Loop time of 95.6365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.566 hours/ns, 10.456 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.554     | 95.554     | 95.554     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015311   | 0.015311   | 0.015311   |   0.0 |  0.02
Output  | 2.9856e-05 | 2.9856e-05 | 2.9856e-05 |   0.0 |  0.00
Modify  | 0.061803   | 0.061803   | 0.061803   |   0.0 |  0.06
Other   |            | 0.005311   |            |       |  0.01

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:       128714 ave      128714 max      128714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128714
Ave neighs/atom = 64.357
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.793478443491, Press = 4.11262587548734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -16018.491     -16018.491     -16099.776     -16099.776      314.57977      314.57977      36193.366      36193.366      588.2221       588.2221     
     14000  -16022.222     -16022.222     -16100.717     -16100.717      303.78645      303.78645      36190.256      36190.256      510.81688      510.81688    
Loop time of 95.8321 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.620 hours/ns, 10.435 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.75      | 95.75      | 95.75      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015236   | 0.015236   | 0.015236   |   0.0 |  0.02
Output  | 5.1978e-05 | 5.1978e-05 | 5.1978e-05 |   0.0 |  0.00
Modify  | 0.06179    | 0.06179    | 0.06179    |   0.0 |  0.06
Other   |            | 0.005312   |            |       |  0.01

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:       128654 ave      128654 max      128654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128654
Ave neighs/atom = 64.327
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.869487989522, Press = 2.82628206396445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -16022.222     -16022.222     -16100.717     -16100.717      303.78645      303.78645      36190.256      36190.256      510.81688      510.81688    
     15000  -16018.585     -16018.585     -16100.948     -16100.948      318.75176      318.75176      36158.023      36158.023      2287.2166      2287.2166    
Loop time of 95.4799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.522 hours/ns, 10.473 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.398     | 95.398     | 95.398     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015153   | 0.015153   | 0.015153   |   0.0 |  0.02
Output  | 3.0467e-05 | 3.0467e-05 | 3.0467e-05 |   0.0 |  0.00
Modify  | 0.061757   | 0.061757   | 0.061757   |   0.0 |  0.06
Other   |            | 0.00531    |            |       |  0.01

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:       128594 ave      128594 max      128594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128594
Ave neighs/atom = 64.297
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.622047050629, Press = 0.174332412329479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -16018.585     -16018.585     -16100.948     -16100.948      318.75176      318.75176      36158.023      36158.023      2287.2166      2287.2166    
     16000  -16021.477     -16021.477     -16102.618     -16102.618      314.02329      314.02329      36224.5        36224.5       -1370.8437     -1370.8437    
Loop time of 95.844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.623 hours/ns, 10.434 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.762     | 95.762     | 95.762     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015157   | 0.015157   | 0.015157   |   0.0 |  0.02
Output  | 3.0347e-05 | 3.0347e-05 | 3.0347e-05 |   0.0 |  0.00
Modify  | 0.061842   | 0.061842   | 0.061842   |   0.0 |  0.06
Other   |            | 0.00533    |            |       |  0.01

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:       128652 ave      128652 max      128652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128652
Ave neighs/atom = 64.326
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.454631582284, Press = -1.22122238677044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -16021.477     -16021.477     -16102.618     -16102.618      314.02329      314.02329      36224.5        36224.5       -1370.8437     -1370.8437    
     17000  -16021.359     -16021.359     -16100.887     -16100.887      307.78034      307.78034      36214.709      36214.709     -809.78234     -809.78234    
Loop time of 95.7989 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.611 hours/ns, 10.439 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.717     | 95.717     | 95.717     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015205   | 0.015205   | 0.015205   |   0.0 |  0.02
Output  | 2.9646e-05 | 2.9646e-05 | 2.9646e-05 |   0.0 |  0.00
Modify  | 0.061752   | 0.061752   | 0.061752   |   0.0 |  0.06
Other   |            | 0.005302   |            |       |  0.01

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:       128592 ave      128592 max      128592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128592
Ave neighs/atom = 64.296
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.483999676292, Press = 6.17883095162647
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -16021.359     -16021.359     -16100.887     -16100.887      307.78034      307.78034      36214.709      36214.709     -809.78234     -809.78234    
     18000  -16021.056     -16021.056     -16097.663     -16097.663      296.48036      296.48036      36163.488      36163.488      1961.236       1961.236     
Loop time of 95.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.532 hours/ns, 10.470 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.432     | 95.432     | 95.432     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015145   | 0.015145   | 0.015145   |   0.0 |  0.02
Output  | 2.9686e-05 | 2.9686e-05 | 2.9686e-05 |   0.0 |  0.00
Modify  | 0.061787   | 0.061787   | 0.061787   |   0.0 |  0.06
Other   |            | 0.005305   |            |       |  0.01

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:       128582 ave      128582 max      128582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128582
Ave neighs/atom = 64.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.507611503017, Press = 2.97630646425067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -16021.056     -16021.056     -16097.663     -16097.663      296.48036      296.48036      36163.488      36163.488      1961.236       1961.236     
     19000  -16017.412     -16017.412     -16095.932     -16095.932      303.88328      303.88328      36180.897      36180.897      1324.9776      1324.9776    
Loop time of 95.9074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.641 hours/ns, 10.427 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.825     | 95.825     | 95.825     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.02
Output  | 2.9987e-05 | 2.9987e-05 | 2.9987e-05 |   0.0 |  0.00
Modify  | 0.061772   | 0.061772   | 0.061772   |   0.0 |  0.06
Other   |            | 0.005317   |            |       |  0.01

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:       128826 ave      128826 max      128826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128826
Ave neighs/atom = 64.413
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.424696414676, Press = -1.26488568034313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -16017.412     -16017.412     -16095.932     -16095.932      303.88328      303.88328      36180.897      36180.897      1324.9776      1324.9776    
     20000  -16019.485     -16019.485     -16098.572     -16098.572      306.07324      306.07324      36201.185      36201.185     -4.2451562     -4.2451562    
Loop time of 95.9536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.654 hours/ns, 10.422 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.871     | 95.871     | 95.871     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015089   | 0.015089   | 0.015089   |   0.0 |  0.02
Output  | 2.9676e-05 | 2.9676e-05 | 2.9676e-05 |   0.0 |  0.00
Modify  | 0.061769   | 0.061769   | 0.061769   |   0.0 |  0.06
Other   |            | 0.00533    |            |       |  0.01

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:       128804 ave      128804 max      128804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128804
Ave neighs/atom = 64.402
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.622492524959, Press = 1.03885544355195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -16019.485     -16019.485     -16098.572     -16098.572      306.07324      306.07324      36201.185      36201.185     -4.2451562     -4.2451562    
     21000  -16021.351     -16021.351     -16100.007     -16100.007      304.40623      304.40623      36203.463      36203.463     -151.66608     -151.66608    
Loop time of 95.8926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.637 hours/ns, 10.428 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.81      | 95.81      | 95.81      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015114   | 0.015114   | 0.015114   |   0.0 |  0.02
Output  | 3.0928e-05 | 3.0928e-05 | 3.0928e-05 |   0.0 |  0.00
Modify  | 0.061803   | 0.061803   | 0.061803   |   0.0 |  0.06
Other   |            | 0.005301   |            |       |  0.01

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:       128764 ave      128764 max      128764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128764
Ave neighs/atom = 64.382
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.647575734129, Press = -0.00706068187502473
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -16021.351     -16021.351     -16100.007     -16100.007      304.40623      304.40623      36203.463      36203.463     -151.66608     -151.66608    
     22000  -16015.78      -16015.78      -16097.098     -16097.098      314.70759      314.70759      36227.763      36227.763     -1190.0745     -1190.0745    
Loop time of 95.7183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.588 hours/ns, 10.447 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.636     | 95.636     | 95.636     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015125   | 0.015125   | 0.015125   |   0.0 |  0.02
Output  | 2.9866e-05 | 2.9866e-05 | 2.9866e-05 |   0.0 |  0.00
Modify  | 0.06179    | 0.06179    | 0.06179    |   0.0 |  0.06
Other   |            | 0.005304   |            |       |  0.01

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:       128668 ave      128668 max      128668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128668
Ave neighs/atom = 64.334
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.659936617088, Press = 0.0358164280485067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -16015.78      -16015.78      -16097.098     -16097.098      314.70759      314.70759      36227.763      36227.763     -1190.0745     -1190.0745    
     23000  -16016.982     -16016.982     -16098.139     -16098.139      314.08642      314.08642      36256.259      36256.259     -2793.445      -2793.445     
Loop time of 95.7077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.585 hours/ns, 10.448 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.625     | 95.625     | 95.625     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015221   | 0.015221   | 0.015221   |   0.0 |  0.02
Output  | 3.208e-05  | 3.208e-05  | 3.208e-05  |   0.0 |  0.00
Modify  | 0.061838   | 0.061838   | 0.061838   |   0.0 |  0.06
Other   |            | 0.005334   |            |       |  0.01

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:       128702 ave      128702 max      128702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128702
Ave neighs/atom = 64.351
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.527794261993, Press = 1.06268417812028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -16016.982     -16016.982     -16098.139     -16098.139      314.08642      314.08642      36256.259      36256.259     -2793.445      -2793.445     
     24000  -16020.683     -16020.683     -16101.78      -16101.78       313.85101      313.85101      36197.848      36197.848      47.730342      47.730342    
Loop time of 95.7861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.607 hours/ns, 10.440 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.704     | 95.704     | 95.704     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01511    | 0.01511    | 0.01511    |   0.0 |  0.02
Output  | 3.0046e-05 | 3.0046e-05 | 3.0046e-05 |   0.0 |  0.00
Modify  | 0.061823   | 0.061823   | 0.061823   |   0.0 |  0.06
Other   |            | 0.005317   |            |       |  0.01

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:       128602 ave      128602 max      128602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128602
Ave neighs/atom = 64.301
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.48302147274, Press = 2.71223175275007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -16020.683     -16020.683     -16101.78      -16101.78       313.85101      313.85101      36197.848      36197.848      47.730342      47.730342    
     25000  -16021.959     -16021.959     -16102.451     -16102.451      311.51429      311.51429      36159.854      36159.854      2042.2171      2042.2171    
Loop time of 95.7627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.601 hours/ns, 10.442 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    | 95.68      | 95.68      | 95.68      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015093   | 0.015093   | 0.015093   |   0.0 |  0.02
Output  | 3.1229e-05 | 3.1229e-05 | 3.1229e-05 |   0.0 |  0.00
Modify  | 0.061834   | 0.061834   | 0.061834   |   0.0 |  0.06
Other   |            | 0.005308   |            |       |  0.01

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:       128600 ave      128600 max      128600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128600
Ave neighs/atom = 64.3
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.455873251786, Press = 2.59122849793371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -16021.959     -16021.959     -16102.451     -16102.451      311.51429      311.51429      36159.854      36159.854      2042.2171      2042.2171    
     26000  -16019.066     -16019.066     -16100.383     -16100.383      314.70628      314.70628      36215.17       36215.17      -781.53669     -781.53669    
Loop time of 95.5081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.530 hours/ns, 10.470 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    | 95.426     | 95.426     | 95.426     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015171   | 0.015171   | 0.015171   |   0.0 |  0.02
Output  | 2.9906e-05 | 2.9906e-05 | 2.9906e-05 |   0.0 |  0.00
Modify  | 0.061754   | 0.061754   | 0.061754   |   0.0 |  0.06
Other   |            | 0.005301   |            |       |  0.01

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:       128612 ave      128612 max      128612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128612
Ave neighs/atom = 64.306
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.452186432828, Press = -0.191658166024049
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -16019.066     -16019.066     -16100.383     -16100.383      314.70628      314.70628      36215.17       36215.17      -781.53669     -781.53669    
     27000  -16020.067     -16020.067     -16103.816     -16103.816      324.11509      324.11509      36196.711      36196.711      13.065635      13.065635    
Loop time of 95.7709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.603 hours/ns, 10.442 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    | 95.689     | 95.689     | 95.689     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01517    | 0.01517    | 0.01517    |   0.0 |  0.02
Output  | 3.0517e-05 | 3.0517e-05 | 3.0517e-05 |   0.0 |  0.00
Modify  | 0.061809   | 0.061809   | 0.061809   |   0.0 |  0.06
Other   |            | 0.005307   |            |       |  0.01

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:       128584 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292
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.505918839876, Press = 1.41910157607582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -16020.067     -16020.067     -16103.816     -16103.816      324.11509      324.11509      36196.711      36196.711      13.065635      13.065635    
     28000  -16020.71      -16020.71      -16097.671     -16097.671      297.84601      297.84601      36213.691      36213.691     -650.96454     -650.96454    
Loop time of 95.9262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.646 hours/ns, 10.425 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    | 95.844     | 95.844     | 95.844     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015117   | 0.015117   | 0.015117   |   0.0 |  0.02
Output  | 3.0257e-05 | 3.0257e-05 | 3.0257e-05 |   0.0 |  0.00
Modify  | 0.061856   | 0.061856   | 0.061856   |   0.0 |  0.06
Other   |            | 0.005337   |            |       |  0.01

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:       128604 ave      128604 max      128604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128604
Ave neighs/atom = 64.302
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.515968654065, Press = 1.48555222580213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -16020.71      -16020.71      -16097.671     -16097.671      297.84601      297.84601      36213.691      36213.691     -650.96454     -650.96454    
     29000  -16015.993     -16015.993     -16096.283     -16096.283      310.72858      310.72858      36153.644      36153.644      2760.3321      2760.3321    
Loop time of 95.7133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.587 hours/ns, 10.448 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    | 95.631     | 95.631     | 95.631     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015181   | 0.015181   | 0.015181   |   0.0 |  0.02
Output  | 2.8343e-05 | 2.8343e-05 | 2.8343e-05 |   0.0 |  0.00
Modify  | 0.061792   | 0.061792   | 0.061792   |   0.0 |  0.06
Other   |            | 0.005327   |            |       |  0.01

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:       128674 ave      128674 max      128674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128674
Ave neighs/atom = 64.337
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.599134210838, Press = 2.87363553011849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -16015.993     -16015.993     -16096.283     -16096.283      310.72858      310.72858      36153.644      36153.644      2760.3321      2760.3321    
     30000  -16018.57      -16018.57      -16102.528     -16102.528      324.92652      324.92652      36161.316      36161.316      1953.1652      1953.1652    
Loop time of 95.8451 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.624 hours/ns, 10.434 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    | 95.763     | 95.763     | 95.763     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015128   | 0.015128   | 0.015128   |   0.0 |  0.02
Output  | 3.0287e-05 | 3.0287e-05 | 3.0287e-05 |   0.0 |  0.00
Modify  | 0.061753   | 0.061753   | 0.061753   |   0.0 |  0.06
Other   |            | 0.00531    |            |       |  0.01

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:       128734 ave      128734 max      128734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128734
Ave neighs/atom = 64.367
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.558170834134, Press = -1.0595489903398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -16018.57      -16018.57      -16102.528     -16102.528      324.92652      324.92652      36161.316      36161.316      1953.1652      1953.1652    
     31000  -16020.501     -16020.501     -16100.363     -16100.363      309.07633      309.07633      36236.954      36236.954     -1967.4582     -1967.4582    
Loop time of 95.7974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.610 hours/ns, 10.439 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    | 95.715     | 95.715     | 95.715     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015058   | 0.015058   | 0.015058   |   0.0 |  0.02
Output  | 2.9917e-05 | 2.9917e-05 | 2.9917e-05 |   0.0 |  0.00
Modify  | 0.061764   | 0.061764   | 0.061764   |   0.0 |  0.06
Other   |            | 0.005316   |            |       |  0.01

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:       128602 ave      128602 max      128602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128602
Ave neighs/atom = 64.301
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.524823639239, Press = 0.356558981641591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -16020.501     -16020.501     -16100.363     -16100.363      309.07633      309.07633      36236.954      36236.954     -1967.4582     -1967.4582    
     32000  -16019.352     -16019.352     -16099.676     -16099.676      310.86225      310.86225      36218.606      36218.606     -878.03867     -878.03867    
Loop time of 95.5904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.553 hours/ns, 10.461 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    | 95.508     | 95.508     | 95.508     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015246   | 0.015246   | 0.015246   |   0.0 |  0.02
Output  | 3.0137e-05 | 3.0137e-05 | 3.0137e-05 |   0.0 |  0.00
Modify  | 0.061723   | 0.061723   | 0.061723   |   0.0 |  0.06
Other   |            | 0.005309   |            |       |  0.01

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:       128574 ave      128574 max      128574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128574
Ave neighs/atom = 64.287
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.474801311531, Press = 1.5897202219783
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -16019.352     -16019.352     -16099.676     -16099.676      310.86225      310.86225      36218.606      36218.606     -878.03867     -878.03867    
     33000  -16021.046     -16021.046     -16101.637     -16101.637      311.89338      311.89338      36174.376      36174.376      1272.7534      1272.7534    
Loop time of 95.8351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.621 hours/ns, 10.435 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    | 95.753     | 95.753     | 95.753     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015187   | 0.015187   | 0.015187   |   0.0 |  0.02
Output  | 3.191e-05  | 3.191e-05  | 3.191e-05  |   0.0 |  0.00
Modify  | 0.061712   | 0.061712   | 0.061712   |   0.0 |  0.06
Other   |            | 0.005336   |            |       |  0.01

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:       128628 ave      128628 max      128628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128628
Ave neighs/atom = 64.314
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.446737179767, Press = 1.53837025710401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -16021.046     -16021.046     -16101.637     -16101.637      311.89338      311.89338      36174.376      36174.376      1272.7534      1272.7534    
     34000  -16017.727     -16017.727     -16095.48      -16095.48       300.90994      300.90994      36195.174      36195.174      601.36586      601.36586    
Loop time of 95.8329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.620 hours/ns, 10.435 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    | 95.751     | 95.751     | 95.751     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015109   | 0.015109   | 0.015109   |   0.0 |  0.02
Output  | 3.1119e-05 | 3.1119e-05 | 3.1119e-05 |   0.0 |  0.00
Modify  | 0.061766   | 0.061766   | 0.061766   |   0.0 |  0.06
Other   |            | 0.005308   |            |       |  0.01

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:       128686 ave      128686 max      128686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128686
Ave neighs/atom = 64.343
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.405541465537, Press = 1.02725943141208
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -16017.727     -16017.727     -16095.48      -16095.48       300.90994      300.90994      36195.174      36195.174      601.36586      601.36586    
     35000  -16020.096     -16020.096     -16101.844     -16101.844      316.37611      316.37611      36196.856      36196.856      36.680868      36.680868    
Loop time of 95.6904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.581 hours/ns, 10.450 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    | 95.608     | 95.608     | 95.608     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015288   | 0.015288   | 0.015288   |   0.0 |  0.02
Output  | 3.0398e-05 | 3.0398e-05 | 3.0398e-05 |   0.0 |  0.00
Modify  | 0.061776   | 0.061776   | 0.061776   |   0.0 |  0.06
Other   |            | 0.005317   |            |       |  0.01

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:       128788 ave      128788 max      128788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128788
Ave neighs/atom = 64.394
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.450417084389, Press = 1.21604038708938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -16020.096     -16020.096     -16101.844     -16101.844      316.37611      316.37611      36196.856      36196.856      36.680868      36.680868    
     36000  -16020.733     -16020.733     -16102.969     -16102.969      318.26246      318.26246      36150.959      36150.959      2499.7893      2499.7893    
Loop time of 95.7402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.594 hours/ns, 10.445 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    | 95.658     | 95.658     | 95.658     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015064   | 0.015064   | 0.015064   |   0.0 |  0.02
Output  | 3.0258e-05 | 3.0258e-05 | 3.0258e-05 |   0.0 |  0.00
Modify  | 0.061741   | 0.061741   | 0.061741   |   0.0 |  0.06
Other   |            | 0.005329   |            |       |  0.01

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:       128666 ave      128666 max      128666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128666
Ave neighs/atom = 64.333
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.378719135675, Press = 1.46101373443025
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -16020.733     -16020.733     -16102.969     -16102.969      318.26246      318.26246      36150.959      36150.959      2499.7893      2499.7893    
     37000  -16015.683     -16015.683     -16099.326     -16099.326      323.7073       323.7073       36174.256      36174.256      1659.488       1659.488     
Loop time of 95.9028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.640 hours/ns, 10.427 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    | 95.819     | 95.819     | 95.819     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015644   | 0.015644   | 0.015644   |   0.0 |  0.02
Output  | 3.2591e-05 | 3.2591e-05 | 3.2591e-05 |   0.0 |  0.00
Modify  | 0.06259    | 0.06259    | 0.06259    |   0.0 |  0.07
Other   |            | 0.005401   |            |       |  0.01

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:       128700 ave      128700 max      128700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128700
Ave neighs/atom = 64.35
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.385941991663, Press = -1.04848836062703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -16015.683     -16015.683     -16099.326     -16099.326      323.7073       323.7073       36174.256      36174.256      1659.488       1659.488     
     38000  -16019.214     -16019.214     -16101.933     -16101.933      320.13055      320.13055      36226.688      36226.688     -1422.7877     -1422.7877    
Loop time of 95.8243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.618 hours/ns, 10.436 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    | 95.742     | 95.742     | 95.742     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015205   | 0.015205   | 0.015205   |   0.0 |  0.02
Output  | 2.7352e-05 | 2.7352e-05 | 2.7352e-05 |   0.0 |  0.00
Modify  | 0.061853   | 0.061853   | 0.061853   |   0.0 |  0.06
Other   |            | 0.005322   |            |       |  0.01

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:       128724 ave      128724 max      128724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128724
Ave neighs/atom = 64.362
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.461638735586, Press = -0.524770034208907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -16019.214     -16019.214     -16101.933     -16101.933      320.13055      320.13055      36226.688      36226.688     -1422.7877     -1422.7877    
     39000  -16018.953     -16018.953     -16100.422     -16100.422      315.29143      315.29143      36210.404      36210.404     -401.49794     -401.49794    
Loop time of 95.7246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.590 hours/ns, 10.447 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    | 95.642     | 95.642     | 95.642     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015213   | 0.015213   | 0.015213   |   0.0 |  0.02
Output  | 2.9326e-05 | 2.9326e-05 | 2.9326e-05 |   0.0 |  0.00
Modify  | 0.061901   | 0.061901   | 0.061901   |   0.0 |  0.06
Other   |            | 0.005317   |            |       |  0.01

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:       128536 ave      128536 max      128536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128536
Ave neighs/atom = 64.268
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.481671680593, Press = 0.935039869793531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -16018.953     -16018.953     -16100.422     -16100.422      315.29143      315.29143      36210.404      36210.404     -401.49794     -401.49794    
     40000  -16018.921     -16018.921     -16100.4       -16100.4        315.33163      315.33163      36202.875      36202.875      6.9262535      6.9262535    
Loop time of 95.8623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.628 hours/ns, 10.432 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    | 95.78      | 95.78      | 95.78      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015178   | 0.015178   | 0.015178   |   0.0 |  0.02
Output  | 2.8193e-05 | 2.8193e-05 | 2.8193e-05 |   0.0 |  0.00
Modify  | 0.061974   | 0.061974   | 0.061974   |   0.0 |  0.06
Other   |            | 0.005343   |            |       |  0.01

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:       128576 ave      128576 max      128576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128576
Ave neighs/atom = 64.288
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.469848244433, Press = 0.768059513873458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -16018.921     -16018.921     -16100.4       -16100.4        315.33163      315.33163      36202.875      36202.875      6.9262535      6.9262535    
     41000  -16021.19      -16021.19      -16100.79      -16100.79       308.06136      308.06136      36212.013      36212.013     -591.57057     -591.57057    
Loop time of 96.1534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.709 hours/ns, 10.400 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    | 96.071     | 96.071     | 96.071     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015164   | 0.015164   | 0.015164   |   0.0 |  0.02
Output  | 3.0408e-05 | 3.0408e-05 | 3.0408e-05 |   0.0 |  0.00
Modify  | 0.061899   | 0.061899   | 0.061899   |   0.0 |  0.06
Other   |            | 0.005316   |            |       |  0.01

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:       128616 ave      128616 max      128616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128616
Ave neighs/atom = 64.308
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.489156222692, Press = 0.278572949250125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -16021.19      -16021.19      -16100.79      -16100.79       308.06136      308.06136      36212.013      36212.013     -591.57057     -591.57057    
     42000  -16020.655     -16020.655     -16100.718     -16100.718      309.85139      309.85139      36236.902      36236.902     -1891.3869     -1891.3869    
Loop time of 95.7835 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.607 hours/ns, 10.440 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    | 95.701     | 95.701     | 95.701     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015155   | 0.015155   | 0.015155   |   0.0 |  0.02
Output  | 3.6188e-05 | 3.6188e-05 | 3.6188e-05 |   0.0 |  0.00
Modify  | 0.061885   | 0.061885   | 0.061885   |   0.0 |  0.06
Other   |            | 0.005318   |            |       |  0.01

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:       128584 ave      128584 max      128584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128584
Ave neighs/atom = 64.292
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.458687331797, Press = 0.657983399958004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -16020.655     -16020.655     -16100.718     -16100.718      309.85139      309.85139      36236.902      36236.902     -1891.3869     -1891.3869    
     43000  -16019.413     -16019.413     -16101.493     -16101.493      317.65917      317.65917      36169.783      36169.783      1673.2037      1673.2037    
Loop time of 95.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.595 hours/ns, 10.445 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    | 95.659     | 95.659     | 95.659     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015089   | 0.015089   | 0.015089   |   0.0 |  0.02
Output  | 3.4585e-05 | 3.4585e-05 | 3.4585e-05 |   0.0 |  0.00
Modify  | 0.06177    | 0.06177    | 0.06177    |   0.0 |  0.06
Other   |            | 0.005302   |            |       |  0.01

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:       128574 ave      128574 max      128574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128574
Ave neighs/atom = 64.287
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.458485925308, Press = 1.43357818978028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -16019.413     -16019.413     -16101.493     -16101.493      317.65917      317.65917      36169.783      36169.783      1673.2037      1673.2037    
     44000  -16018.888     -16018.888     -16098.378     -16098.378      307.63649      307.63649      36163.734      36163.734      2240.8093      2240.8093    
Loop time of 95.7364 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.593 hours/ns, 10.445 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    | 95.654     | 95.654     | 95.654     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015079   | 0.015079   | 0.015079   |   0.0 |  0.02
Output  | 3.6709e-05 | 3.6709e-05 | 3.6709e-05 |   0.0 |  0.00
Modify  | 0.061799   | 0.061799   | 0.061799   |   0.0 |  0.06
Other   |            | 0.005302   |            |       |  0.01

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:       128672 ave      128672 max      128672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128672
Ave neighs/atom = 64.336
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.425620909975, Press = -0.491029159139899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -16018.888     -16018.888     -16098.378     -16098.378      307.63649      307.63649      36163.734      36163.734      2240.8093      2240.8093    
     45000  -16020.628     -16020.628     -16100.268     -16100.268      308.21582      308.21582      36231.757      36231.757     -1579.3542     -1579.3542    
Loop time of 95.8937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.637 hours/ns, 10.428 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    | 95.811     | 95.811     | 95.811     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015122   | 0.015122   | 0.015122   |   0.0 |  0.02
Output  | 3.3934e-05 | 3.3934e-05 | 3.3934e-05 |   0.0 |  0.00
Modify  | 0.061833   | 0.061833   | 0.061833   |   0.0 |  0.06
Other   |            | 0.005313   |            |       |  0.01

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:       128822 ave      128822 max      128822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128822
Ave neighs/atom = 64.411
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.45374080784, Press = 0.223542382138913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -16020.628     -16020.628     -16100.268     -16100.268      308.21582      308.21582      36231.757      36231.757     -1579.3542     -1579.3542    
     46000  -16019.899     -16019.899     -16101.626     -16101.626      316.29459      316.29459      36222.175      36222.175     -1066.8313     -1066.8313    
Loop time of 95.7072 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.585 hours/ns, 10.449 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    | 95.625     | 95.625     | 95.625     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015298   | 0.015298   | 0.015298   |   0.0 |  0.02
Output  | 7.1765e-05 | 7.1765e-05 | 7.1765e-05 |   0.0 |  0.00
Modify  | 0.062002   | 0.062002   | 0.062002   |   0.0 |  0.06
Other   |            | 0.005319   |            |       |  0.01

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:       128570 ave      128570 max      128570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128570
Ave neighs/atom = 64.285
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.386366221889, Press = 1.12221053427041
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -16019.899     -16019.899     -16101.626     -16101.626      316.29459      316.29459      36222.175      36222.175     -1066.8313     -1066.8313    
     47000  -16018.683     -16018.683     -16100.022     -16100.022      314.79274      314.79274      36184.756      36184.756      958.72474      958.72474    
Loop time of 95.6646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.573 hours/ns, 10.453 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    | 95.582     | 95.582     | 95.582     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015231   | 0.015231   | 0.015231   |   0.0 |  0.02
Output  | 3.4485e-05 | 3.4485e-05 | 3.4485e-05 |   0.0 |  0.00
Modify  | 0.061833   | 0.061833   | 0.061833   |   0.0 |  0.06
Other   |            | 0.005335   |            |       |  0.01

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:       128606 ave      128606 max      128606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128606
Ave neighs/atom = 64.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.360217397279, Press = 0.512733413286526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -16018.683     -16018.683     -16100.022     -16100.022      314.79274      314.79274      36184.756      36184.756      958.72474      958.72474    
     48000  -16021.38      -16021.38      -16100.309     -16100.309      305.46593      305.46593      36188.75       36188.75       632.08411      632.08411    
Loop time of 96.0726 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.687 hours/ns, 10.409 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    | 95.99      | 95.99      | 95.99      |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015121   | 0.015121   | 0.015121   |   0.0 |  0.02
Output  | 3.4986e-05 | 3.4986e-05 | 3.4986e-05 |   0.0 |  0.00
Modify  | 0.061753   | 0.061753   | 0.061753   |   0.0 |  0.06
Other   |            | 0.0053     |            |       |  0.01

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:       128662 ave      128662 max      128662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128662
Ave neighs/atom = 64.331
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.305115124663, Press = 0.685146133468645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -16021.38      -16021.38      -16100.309     -16100.309      305.46593      305.46593      36188.75       36188.75       632.08411      632.08411    
     49000  -16016.208     -16016.208     -16098.89      -16098.89       319.98641      319.98641      36162.844      36162.844      2294.3182      2294.3182    
Loop time of 96.0571 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.683 hours/ns, 10.410 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    | 95.975     | 95.975     | 95.975     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01521    | 0.01521    | 0.01521    |   0.0 |  0.02
Output  | 3.4966e-05 | 3.4966e-05 | 3.4966e-05 |   0.0 |  0.00
Modify  | 0.061931   | 0.061931   | 0.061931   |   0.0 |  0.06
Other   |            | 0.00536    |            |       |  0.01

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:       128640 ave      128640 max      128640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128640
Ave neighs/atom = 64.32
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.294787677862, Press = -1.09424055021128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -16016.208     -16016.208     -16098.89      -16098.89       319.98641      319.98641      36162.844      36162.844      2294.3182      2294.3182    
     50000  -16016.745     -16016.745     -16097.656     -16097.656      313.13444      313.13444      36233.598      36233.598     -1371.7929     -1371.7929    
Loop time of 96.0198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.672 hours/ns, 10.415 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    | 95.937     | 95.937     | 95.937     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015226   | 0.015226   | 0.015226   |   0.0 |  0.02
Output  | 3.4154e-05 | 3.4154e-05 | 3.4154e-05 |   0.0 |  0.00
Modify  | 0.061977   | 0.061977   | 0.061977   |   0.0 |  0.06
Other   |            | 0.005458   |            |       |  0.01

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:       128742 ave      128742 max      128742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128742
Ave neighs/atom = 64.371
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
36201.0998233317

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0