# 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.532111041247845*${_u_distance}
variable latticeconst_converted equal 3.532111041247845*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.53211104124785
Lattice spacing in x,y,z = 3.532111 3.532111 3.532111
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.32111 35.32111 35.32111)
  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 (35.32111 35.32111 35.32111)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Li

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

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


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 44065.9406253475 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_427397414195_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 = 11 11 11
  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.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3215.8636     -3215.8636     -3296.7787     -3296.7787      313.15         313.15         44065.941      44065.941      1961.3095      1961.3095    
      1000  -3121.5912     -3121.5912     -3204.6688     -3204.6688      321.51895      321.51895      45168.019      45168.019     -633.84064     -633.84064    
Loop time of 202.635 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.288 hours/ns, 4.935 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.61     | 201.61     | 201.61     |   0.0 | 99.49
Neigh   | 0.44467    | 0.44467    | 0.44467    |   0.0 |  0.22
Comm    | 0.10071    | 0.10071    | 0.10071    |   0.0 |  0.05
Output  | 0.00021094 | 0.00021094 | 0.00021094 |   0.0 |  0.00
Modify  | 0.41713    | 0.41713    | 0.41713    |   0.0 |  0.21
Other   |            | 0.06095    |            |       |  0.03

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

Total # of neighbors = 120648
Ave neighs/atom = 60.324
Neighbor list builds = 19
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -3121.5912     -3121.5912     -3204.6688     -3204.6688      321.51895      321.51895      45168.019      45168.019     -633.84064     -633.84064    
      2000  -3130.5854     -3130.5854     -3209.3869     -3209.3869      304.96992      304.96992      44741.667      44741.667      101.09308      101.09308    
Loop time of 204.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.423 ns/day, 56.791 hours/ns, 4.891 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    | 203.3      | 203.3      | 203.3      |   0.0 | 99.44
Neigh   | 0.56782    | 0.56782    | 0.56782    |   0.0 |  0.28
Comm    | 0.10202    | 0.10202    | 0.10202    |   0.0 |  0.05
Output  | 0.00028305 | 0.00028305 | 0.00028305 |   0.0 |  0.00
Modify  | 0.41661    | 0.41661    | 0.41661    |   0.0 |  0.20
Other   |            | 0.06059    |            |       |  0.03

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

Total # of neighbors = 121072
Ave neighs/atom = 60.536
Neighbor list builds = 24
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3130.5854     -3130.5854     -3209.3869     -3209.3869      304.96992      304.96992      44741.667      44741.667      101.09308      101.09308    
      3000  -3122.4202     -3122.4202     -3204.1675     -3204.1675      316.37071      316.37071      44792.548      44792.548      266.60553      266.60553    
Loop time of 202.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.140 hours/ns, 4.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.98     | 200.98     | 200.98     |   0.0 | 99.44
Neigh   | 0.54108    | 0.54108    | 0.54108    |   0.0 |  0.27
Comm    | 0.10292    | 0.10292    | 0.10292    |   0.0 |  0.05
Output  | 0.0002097  | 0.0002097  | 0.0002097  |   0.0 |  0.00
Modify  | 0.42031    | 0.42031    | 0.42031    |   0.0 |  0.21
Other   |            | 0.061      |            |       |  0.03

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

Total # of neighbors = 121324
Ave neighs/atom = 60.662
Neighbor list builds = 23
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -3122.4202     -3122.4202     -3204.1675     -3204.1675      316.37071      316.37071      44792.548      44792.548      266.60553      266.60553    
      4000  -3127.7537     -3127.7537     -3208.8417     -3208.8417      313.81903      313.81903      44722.063      44722.063      207.77086      207.77086    
Loop time of 186.24 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.464 ns/day, 51.733 hours/ns, 5.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.18     | 185.18     | 185.18     |   0.0 | 99.43
Neigh   | 0.53599    | 0.53599    | 0.53599    |   0.0 |  0.29
Comm    | 0.094419   | 0.094419   | 0.094419   |   0.0 |  0.05
Output  | 0.0002041  | 0.0002041  | 0.0002041  |   0.0 |  0.00
Modify  | 0.36877    | 0.36877    | 0.36877    |   0.0 |  0.20
Other   |            | 0.058      |            |       |  0.03

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

Total # of neighbors = 121156
Ave neighs/atom = 60.578
Neighbor list builds = 24
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -3127.7537     -3127.7537     -3208.8417     -3208.8417      313.81903      313.81903      44722.063      44722.063      207.77086      207.77086    
      5000  -3124.0313     -3124.0313     -3206.568      -3206.568       319.42532      319.42532      45042.497      45042.497     -427.92541     -427.92541    
Loop time of 172.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.037 hours/ns, 5.783 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.98     | 171.98     | 171.98     |   0.0 | 99.45
Neigh   | 0.47547    | 0.47547    | 0.47547    |   0.0 |  0.27
Comm    | 0.088524   | 0.088524   | 0.088524   |   0.0 |  0.05
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.33613    | 0.33613    | 0.33613    |   0.0 |  0.19
Other   |            | 0.05507    |            |       |  0.03

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

Total # of neighbors = 120900
Ave neighs/atom = 60.45
Neighbor list builds = 22
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 = 316.820799899891, Press = -232.40688562345
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -3124.0313     -3124.0313     -3206.568      -3206.568       319.42532      319.42532      45042.497      45042.497     -427.92541     -427.92541    
      6000  -3128.9635     -3128.9635     -3209.1166     -3209.1166      310.20074      310.20074      44854.61       44854.61      -103.6916      -103.6916     
Loop time of 173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.056 hours/ns, 5.780 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.01     | 172.01     | 172.01     |   0.0 | 99.42
Neigh   | 0.49643    | 0.49643    | 0.49643    |   0.0 |  0.29
Comm    | 0.089098   | 0.089098   | 0.089098   |   0.0 |  0.05
Output  | 0.00016626 | 0.00016626 | 0.00016626 |   0.0 |  0.00
Modify  | 0.35398    | 0.35398    | 0.35398    |   0.0 |  0.20
Other   |            | 0.05509    |            |       |  0.03

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

Total # of neighbors = 120940
Ave neighs/atom = 60.47
Neighbor list builds = 23
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.194408968562, Press = -51.0241949701025
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3128.9635     -3128.9635     -3209.1166     -3209.1166      310.20074      310.20074      44854.61       44854.61      -103.6916      -103.6916     
      7000  -3127.7259     -3127.7259     -3208.1197     -3208.1197      311.13215      311.13215      44708.658      44708.658      226.48859      226.48859    
Loop time of 173.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.088 hours/ns, 5.776 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.12     | 172.12     | 172.12     |   0.0 | 99.43
Neigh   | 0.4976     | 0.4976     | 0.4976     |   0.0 |  0.29
Comm    | 0.089201   | 0.089201   | 0.089201   |   0.0 |  0.05
Output  | 0.00016699 | 0.00016699 | 0.00016699 |   0.0 |  0.00
Modify  | 0.35378    | 0.35378    | 0.35378    |   0.0 |  0.20
Other   |            | 0.05463    |            |       |  0.03

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

Total # of neighbors = 121222
Ave neighs/atom = 60.611
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.37941393406, Press = -23.7171016917494
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3127.7259     -3127.7259     -3208.1197     -3208.1197      311.13215      311.13215      44708.658      44708.658      226.48859      226.48859    
      8000  -3126.5545     -3126.5545     -3207.1665     -3207.1665      311.97674      311.97674      44651.319      44651.319      459.8234       459.8234     
Loop time of 173.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.498 ns/day, 48.166 hours/ns, 5.767 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.4      | 172.4      | 172.4      |   0.0 | 99.43
Neigh   | 0.49757    | 0.49757    | 0.49757    |   0.0 |  0.29
Comm    | 0.089148   | 0.089148   | 0.089148   |   0.0 |  0.05
Output  | 0.00016602 | 0.00016602 | 0.00016602 |   0.0 |  0.00
Modify  | 0.35344    | 0.35344    | 0.35344    |   0.0 |  0.20
Other   |            | 0.05497    |            |       |  0.03

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

Total # of neighbors = 121456
Ave neighs/atom = 60.728
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.675313822072, Press = -4.46489604261646
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3126.5545     -3126.5545     -3207.1665     -3207.1665      311.97674      311.97674      44651.319      44651.319      459.8234       459.8234     
      9000  -3124.4415     -3124.4415     -3205.0372     -3205.0372      311.9138       311.9138       44882.742      44882.742      11.537284      11.537284    
Loop time of 172.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.048 hours/ns, 5.781 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.98     | 171.98     | 171.98     |   0.0 | 99.42
Neigh   | 0.49712    | 0.49712    | 0.49712    |   0.0 |  0.29
Comm    | 0.089412   | 0.089412   | 0.089412   |   0.0 |  0.05
Output  | 0.00019594 | 0.00019594 | 0.00019594 |   0.0 |  0.00
Modify  | 0.35352    | 0.35352    | 0.35352    |   0.0 |  0.20
Other   |            | 0.0548     |            |       |  0.03

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

Total # of neighbors = 121326
Ave neighs/atom = 60.663
Neighbor list builds = 23
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.4189094152, Press = -8.02648135454585
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3124.4415     -3124.4415     -3205.0372     -3205.0372      311.9138       311.9138       44882.742      44882.742      11.537284      11.537284    
     10000  -3126.9833     -3126.9833     -3207.7183     -3207.7183      312.45311      312.45311      44796.391      44796.391      74.779274      74.779274    
Loop time of 180.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.131 hours/ns, 5.541 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.44     | 179.44     | 179.44     |   0.0 | 99.43
Neigh   | 0.50615    | 0.50615    | 0.50615    |   0.0 |  0.28
Comm    | 0.093077   | 0.093077   | 0.093077   |   0.0 |  0.05
Output  | 0.00016728 | 0.00016728 | 0.00016728 |   0.0 |  0.00
Modify  | 0.37517    | 0.37517    | 0.37517    |   0.0 |  0.21
Other   |            | 0.05644    |            |       |  0.03

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

Total # of neighbors = 121300
Ave neighs/atom = 60.65
Neighbor list builds = 23
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.609796614928, Press = -5.05954619092278
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3126.9833     -3126.9833     -3207.7183     -3207.7183      312.45311      312.45311      44796.391      44796.391      74.779274      74.779274    
     11000  -3124.5389     -3124.5389     -3206.8913     -3206.8913      318.71249      318.71249      44888.818      44888.818     -70.332983     -70.332983    
Loop time of 202.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.339 hours/ns, 4.930 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    | 201.68     | 201.68     | 201.68     |   0.0 | 99.43
Neigh   | 0.54239    | 0.54239    | 0.54239    |   0.0 |  0.27
Comm    | 0.10274    | 0.10274    | 0.10274    |   0.0 |  0.05
Output  | 0.0002138  | 0.0002138  | 0.0002138  |   0.0 |  0.00
Modify  | 0.44074    | 0.44074    | 0.44074    |   0.0 |  0.22
Other   |            | 0.06086    |            |       |  0.03

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

Total # of neighbors = 121292
Ave neighs/atom = 60.646
Neighbor list builds = 23
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.766335314626, Press = -6.786853614915
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3124.5389     -3124.5389     -3206.8913     -3206.8913      318.71249      318.71249      44888.818      44888.818     -70.332983     -70.332983    
     12000  -3127.3679     -3127.3679     -3207.2342     -3207.2342      309.09059      309.09059      44869.292      44869.292     -110.33226     -110.33226    
Loop time of 198.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.048 hours/ns, 5.046 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.02     | 197.02     | 197.02     |   0.0 | 99.42
Neigh   | 0.56011    | 0.56011    | 0.56011    |   0.0 |  0.28
Comm    | 0.10203    | 0.10203    | 0.10203    |   0.0 |  0.05
Output  | 0.00016614 | 0.00016614 | 0.00016614 |   0.0 |  0.00
Modify  | 0.42735    | 0.42735    | 0.42735    |   0.0 |  0.22
Other   |            | 0.05963    |            |       |  0.03

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

Total # of neighbors = 121182
Ave neighs/atom = 60.591
Neighbor list builds = 24
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.486517274548, Press = -1.65482073174939
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -3127.3679     -3127.3679     -3207.2342     -3207.2342      309.09059      309.09059      44869.292      44869.292     -110.33226     -110.33226    
     13000  -3125.2527     -3125.2527     -3205.6777     -3205.6777      311.25285      311.25285      44946.559      44946.559     -235.1225      -235.1225     
Loop time of 199.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.509 hours/ns, 5.004 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.67     | 198.67     | 198.67     |   0.0 | 99.42
Neigh   | 0.56474    | 0.56474    | 0.56474    |   0.0 |  0.28
Comm    | 0.10246    | 0.10246    | 0.10246    |   0.0 |  0.05
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.43343    | 0.43343    | 0.43343    |   0.0 |  0.22
Other   |            | 0.06013    |            |       |  0.03

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

Total # of neighbors = 120964
Ave neighs/atom = 60.482
Neighbor list builds = 24
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.408399962545, Press = -7.00342392245552
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -3125.2527     -3125.2527     -3205.6777     -3205.6777      311.25285      311.25285      44946.559      44946.559     -235.1225      -235.1225     
     14000  -3121.6501     -3121.6501     -3204.8693     -3204.8693      322.06692      322.06692      44860.673      44860.673      138.99966      138.99966    
Loop time of 178.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.483 ns/day, 49.671 hours/ns, 5.592 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 177.77     | 177.77     | 177.77     |   0.0 | 99.41
Neigh   | 0.53093    | 0.53093    | 0.53093    |   0.0 |  0.30
Comm    | 0.093195   | 0.093195   | 0.093195   |   0.0 |  0.05
Output  | 0.00044915 | 0.00044915 | 0.00044915 |   0.0 |  0.00
Modify  | 0.36863    | 0.36863    | 0.36863    |   0.0 |  0.21
Other   |            | 0.05569    |            |       |  0.03

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

Total # of neighbors = 121068
Ave neighs/atom = 60.534
Neighbor list builds = 24
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.310292743249, Press = -5.80264300452008
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3121.6501     -3121.6501     -3204.8693     -3204.8693      322.06692      322.06692      44860.673      44860.673      138.99966      138.99966    
     15000  -3129.0614     -3129.0614     -3208.0306     -3208.0306      305.6188       305.6188       44682.522      44682.522      365.65333      365.65333    
Loop time of 174.282 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.26     | 173.26     | 173.26     |   0.0 | 99.41
Neigh   | 0.52225    | 0.52225    | 0.52225    |   0.0 |  0.30
Comm    | 0.091205   | 0.091205   | 0.091205   |   0.0 |  0.05
Output  | 0.00016889 | 0.00016889 | 0.00016889 |   0.0 |  0.00
Modify  | 0.35588    | 0.35588    | 0.35588    |   0.0 |  0.20
Other   |            | 0.05372    |            |       |  0.03

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

Total # of neighbors = 121324
Ave neighs/atom = 60.662
Neighbor list builds = 24
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.361533928522, Press = -3.25391411371245
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -3129.0614     -3129.0614     -3208.0306     -3208.0306      305.6188       305.6188       44682.522      44682.522      365.65333      365.65333    
     16000  -3121.9743     -3121.9743     -3205.51       -3205.51        323.29179      323.29179      44814.686      44814.686      217.69958      217.69958    
Loop time of 174.929 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 173.9      | 173.9      | 173.9      |   0.0 | 99.41
Neigh   | 0.52146    | 0.52146    | 0.52146    |   0.0 |  0.30
Comm    | 0.091612   | 0.091612   | 0.091612   |   0.0 |  0.05
Output  | 0.00016688 | 0.00016688 | 0.00016688 |   0.0 |  0.00
Modify  | 0.35845    | 0.35845    | 0.35845    |   0.0 |  0.20
Other   |            | 0.05408    |            |       |  0.03

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

Total # of neighbors = 121284
Ave neighs/atom = 60.642
Neighbor list builds = 24
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.484784517287, Press = -2.15006445456354
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3121.9743     -3121.9743     -3205.51       -3205.51        323.29179      323.29179      44814.686      44814.686      217.69958      217.69958    
     17000  -3126.7446     -3126.7446     -3205.4619     -3205.4619      304.64411      304.64411      44996.294      44996.294     -363.02381     -363.02381    
Loop time of 192.428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.449 ns/day, 53.452 hours/ns, 5.197 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    | 191.31     | 191.31     | 191.31     |   0.0 | 99.42
Neigh   | 0.54972    | 0.54972    | 0.54972    |   0.0 |  0.29
Comm    | 0.09909    | 0.09909    | 0.09909    |   0.0 |  0.05
Output  | 0.00016756 | 0.00016756 | 0.00016756 |   0.0 |  0.00
Modify  | 0.40831    | 0.40831    | 0.40831    |   0.0 |  0.21
Other   |            | 0.05919    |            |       |  0.03

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

Total # of neighbors = 120884
Ave neighs/atom = 60.442
Neighbor list builds = 24
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.397574255237, Press = -3.27372427741718
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3126.7446     -3126.7446     -3205.4619     -3205.4619      304.64411      304.64411      44996.294      44996.294     -363.02381     -363.02381    
     18000  -3125.3825     -3125.3825     -3207.2995     -3207.2995      317.02753      317.02753      44957.831      44957.831     -316.56247     -316.56247    
Loop time of 180.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.165 hours/ns, 5.537 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.56     | 179.56     | 179.56     |   0.0 | 99.43
Neigh   | 0.50912    | 0.50912    | 0.50912    |   0.0 |  0.28
Comm    | 0.093398   | 0.093398   | 0.093398   |   0.0 |  0.05
Output  | 0.00021445 | 0.00021445 | 0.00021445 |   0.0 |  0.00
Modify  | 0.37463    | 0.37463    | 0.37463    |   0.0 |  0.21
Other   |            | 0.05666    |            |       |  0.03

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

Total # of neighbors = 121018
Ave neighs/atom = 60.509
Neighbor list builds = 23
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.31441162469, Press = -4.63305345732156
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3125.3825     -3125.3825     -3207.2995     -3207.2995      317.02753      317.02753      44957.831      44957.831     -316.56247     -316.56247    
     19000  -3126.6986     -3126.6986     -3207.2025     -3207.2025      311.55841      311.55841      44634.026      44634.026      523.81474      523.81474    
Loop time of 201.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.104 hours/ns, 4.951 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.83     | 200.83     | 200.83     |   0.0 | 99.44
Neigh   | 0.53833    | 0.53833    | 0.53833    |   0.0 |  0.27
Comm    | 0.10132    | 0.10132    | 0.10132    |   0.0 |  0.05
Output  | 0.0001678  | 0.0001678  | 0.0001678  |   0.0 |  0.00
Modify  | 0.43869    | 0.43869    | 0.43869    |   0.0 |  0.22
Other   |            | 0.06093    |            |       |  0.03

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

Total # of neighbors = 121048
Ave neighs/atom = 60.524
Neighbor list builds = 23
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.453122875101, Press = -4.86371361009389
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -3126.6986     -3126.6986     -3207.2025     -3207.2025      311.55841      311.55841      44634.026      44634.026      523.81474      523.81474    
     20000  -3128.3391     -3128.3391     -3209.902      -3209.902       315.65686      315.65686      44662.096      44662.096      336.76017      336.76017    
Loop time of 202.478 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.244 hours/ns, 4.939 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.27     | 201.27     | 201.27     |   0.0 | 99.41
Neigh   | 0.59061    | 0.59061    | 0.59061    |   0.0 |  0.29
Comm    | 0.10401    | 0.10401    | 0.10401    |   0.0 |  0.05
Output  | 0.00016911 | 0.00016911 | 0.00016911 |   0.0 |  0.00
Modify  | 0.44662    | 0.44662    | 0.44662    |   0.0 |  0.22
Other   |            | 0.06179    |            |       |  0.03

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

Total # of neighbors = 121338
Ave neighs/atom = 60.669
Neighbor list builds = 25
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.304031272025, Press = -1.73621208216408
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3128.3391     -3128.3391     -3209.902      -3209.902       315.65686      315.65686      44662.096      44662.096      336.76017      336.76017    
     21000  -3123.8811     -3123.8811     -3206.8918     -3206.8918      321.26008      321.26008      44872.313      44872.313     -37.921149     -37.921149    
Loop time of 202.315 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.199 hours/ns, 4.943 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.15     | 201.15     | 201.15     |   0.0 | 99.42
Neigh   | 0.56225    | 0.56225    | 0.56225    |   0.0 |  0.28
Comm    | 0.10299    | 0.10299    | 0.10299    |   0.0 |  0.05
Output  | 0.00027013 | 0.00027013 | 0.00027013 |   0.0 |  0.00
Modify  | 0.43821    | 0.43821    | 0.43821    |   0.0 |  0.22
Other   |            | 0.06013    |            |       |  0.03

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

Total # of neighbors = 120928
Ave neighs/atom = 60.464
Neighbor list builds = 24
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.324396278201, Press = -1.46823546225624
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -3123.8811     -3123.8811     -3206.8918     -3206.8918      321.26008      321.26008      44872.313      44872.313     -37.921149     -37.921149    
     22000  -3128.6685     -3128.6685     -3207.4069     -3207.4069      304.72548      304.72548      44766.843      44766.843      138.10359      138.10359    
Loop time of 203.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.399 hours/ns, 4.925 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.89     | 201.89     | 201.89     |   0.0 | 99.44
Neigh   | 0.54044    | 0.54044    | 0.54044    |   0.0 |  0.27
Comm    | 0.10152    | 0.10152    | 0.10152    |   0.0 |  0.05
Output  | 0.00022706 | 0.00022706 | 0.00022706 |   0.0 |  0.00
Modify  | 0.43847    | 0.43847    | 0.43847    |   0.0 |  0.22
Other   |            | 0.0604     |            |       |  0.03

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

Total # of neighbors = 121116
Ave neighs/atom = 60.558
Neighbor list builds = 23
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.251587610494, Press = -2.15217746183622
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3128.6685     -3128.6685     -3207.4069     -3207.4069      304.72548      304.72548      44766.843      44766.843      138.10359      138.10359    
     23000  -3125.8219     -3125.8219     -3210.0032     -3210.0032      325.79012      325.79012      44803.23       44803.23       37.077974      37.077974    
Loop time of 202.163 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.156 hours/ns, 4.947 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.01     | 201.01     | 201.01     |   0.0 | 99.43
Neigh   | 0.54339    | 0.54339    | 0.54339    |   0.0 |  0.27
Comm    | 0.10304    | 0.10304    | 0.10304    |   0.0 |  0.05
Output  | 0.00016726 | 0.00016726 | 0.00016726 |   0.0 |  0.00
Modify  | 0.44396    | 0.44396    | 0.44396    |   0.0 |  0.22
Other   |            | 0.06134    |            |       |  0.03

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

Total # of neighbors = 121052
Ave neighs/atom = 60.526
Neighbor list builds = 23
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.201357927076, Press = -1.14657313245216
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3125.8219     -3125.8219     -3210.0032     -3210.0032      325.79012      325.79012      44803.23       44803.23       37.077974      37.077974    
     24000  -3127.6295     -3127.6295     -3209.3198     -3209.3198      316.14993      316.14993      44701.686      44701.686      338.90535      338.90535    
Loop time of 202.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.118 hours/ns, 4.950 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.89     | 200.89     | 200.89     |   0.0 | 99.44
Neigh   | 0.54042    | 0.54042    | 0.54042    |   0.0 |  0.27
Comm    | 0.10098    | 0.10098    | 0.10098    |   0.0 |  0.05
Output  | 0.00022673 | 0.00022673 | 0.00022673 |   0.0 |  0.00
Modify  | 0.43794    | 0.43794    | 0.43794    |   0.0 |  0.22
Other   |            | 0.06032    |            |       |  0.03

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

Total # of neighbors = 120970
Ave neighs/atom = 60.485
Neighbor list builds = 23
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.184321610263, Press = -0.858513945191517
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -3127.6295     -3127.6295     -3209.3198     -3209.3198      316.14993      316.14993      44701.686      44701.686      338.90535      338.90535    
     25000  -3125.3176     -3125.3176     -3206.8574     -3206.8574      315.56765      315.56765      45081.823      45081.823     -541.16256     -541.16256    
Loop time of 201.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.075 hours/ns, 4.954 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.73     | 200.73     | 200.73     |   0.0 | 99.43
Neigh   | 0.54554    | 0.54554    | 0.54554    |   0.0 |  0.27
Comm    | 0.10253    | 0.10253    | 0.10253    |   0.0 |  0.05
Output  | 0.00022836 | 0.00022836 | 0.00022836 |   0.0 |  0.00
Modify  | 0.43547    | 0.43547    | 0.43547    |   0.0 |  0.22
Other   |            | 0.0602     |            |       |  0.03

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

Total # of neighbors = 121044
Ave neighs/atom = 60.522
Neighbor list builds = 23
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.143120329074, Press = -0.697969031442706
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -3125.3176     -3125.3176     -3206.8574     -3206.8574      315.56765      315.56765      45081.823      45081.823     -541.16256     -541.16256    
     26000  -3126.4856     -3126.4856     -3205.1057     -3205.1057      304.26776      304.26776      44995.411      44995.411     -418.74753     -418.74753    
Loop time of 202.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.356 hours/ns, 4.929 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    | 201.72     | 201.72     | 201.72     |   0.0 | 99.42
Neigh   | 0.56871    | 0.56871    | 0.56871    |   0.0 |  0.28
Comm    | 0.10296    | 0.10296    | 0.10296    |   0.0 |  0.05
Output  | 0.00026633 | 0.00026633 | 0.00026633 |   0.0 |  0.00
Modify  | 0.43565    | 0.43565    | 0.43565    |   0.0 |  0.21
Other   |            | 0.0603     |            |       |  0.03

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

Total # of neighbors = 120912
Ave neighs/atom = 60.456
Neighbor list builds = 24
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.160065813346, Press = -3.53696861866628
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3126.4856     -3126.4856     -3205.1057     -3205.1057      304.26776      304.26776      44995.411      44995.411     -418.74753     -418.74753    
     27000  -3121.814      -3121.814      -3204.843      -3204.843       321.33066      321.33066      44965.813      44965.813     -192.08404     -192.08404    
Loop time of 202.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.336 hours/ns, 4.931 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    | 201.62     | 201.62     | 201.62     |   0.0 | 99.41
Neigh   | 0.57405    | 0.57405    | 0.57405    |   0.0 |  0.28
Comm    | 0.10477    | 0.10477    | 0.10477    |   0.0 |  0.05
Output  | 0.00020507 | 0.00020507 | 0.00020507 |   0.0 |  0.00
Modify  | 0.44669    | 0.44669    | 0.44669    |   0.0 |  0.22
Other   |            | 0.06129    |            |       |  0.03

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

Total # of neighbors = 121016
Ave neighs/atom = 60.508
Neighbor list builds = 24
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.291730468627, Press = -2.59169898293433
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3121.814      -3121.814      -3204.843      -3204.843       321.33066      321.33066      44965.813      44965.813     -192.08404     -192.08404    
     28000  -3126.689      -3126.689      -3207.6061     -3207.6061      313.15744      313.15744      44845.528      44845.528      38.16654       38.16654     
Loop time of 202.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.188 hours/ns, 4.944 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.11     | 201.11     | 201.11     |   0.0 | 99.42
Neigh   | 0.56612    | 0.56612    | 0.56612    |   0.0 |  0.28
Comm    | 0.10176    | 0.10176    | 0.10176    |   0.0 |  0.05
Output  | 0.00016732 | 0.00016732 | 0.00016732 |   0.0 |  0.00
Modify  | 0.43638    | 0.43638    | 0.43638    |   0.0 |  0.22
Other   |            | 0.06044    |            |       |  0.03

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

Total # of neighbors = 120912
Ave neighs/atom = 60.456
Neighbor list builds = 24
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.362964490023, Press = -1.09822263599782
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3126.689      -3126.689      -3207.6061     -3207.6061      313.15744      313.15744      44845.528      44845.528      38.16654       38.16654     
     29000  -3125.5824     -3125.5824     -3206.5805     -3206.5805      313.47111      313.47111      44989.079      44989.079     -356.4759      -356.4759     
Loop time of 201.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.076 hours/ns, 4.954 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.74     | 200.74     | 200.74     |   0.0 | 99.44
Neigh   | 0.54185    | 0.54185    | 0.54185    |   0.0 |  0.27
Comm    | 0.10135    | 0.10135    | 0.10135    |   0.0 |  0.05
Output  | 0.00021191 | 0.00021191 | 0.00021191 |   0.0 |  0.00
Modify  | 0.43188    | 0.43188    | 0.43188    |   0.0 |  0.21
Other   |            | 0.06001    |            |       |  0.03

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

Total # of neighbors = 120996
Ave neighs/atom = 60.498
Neighbor list builds = 23
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.32943911982, Press = -2.18767029913689
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -3125.5824     -3125.5824     -3206.5805     -3206.5805      313.47111      313.47111      44989.079      44989.079     -356.4759      -356.4759     
     30000  -3123.8873     -3123.8873     -3205.508      -3205.508       315.88028      315.88028      44818.633      44818.633      58.335697      58.335697    
Loop time of 201.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.022 hours/ns, 4.958 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.54     | 200.54     | 200.54     |   0.0 | 99.43
Neigh   | 0.54276    | 0.54276    | 0.54276    |   0.0 |  0.27
Comm    | 0.10175    | 0.10175    | 0.10175    |   0.0 |  0.05
Output  | 0.00021393 | 0.00021393 | 0.00021393 |   0.0 |  0.00
Modify  | 0.43588    | 0.43588    | 0.43588    |   0.0 |  0.22
Other   |            | 0.0599     |            |       |  0.03

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

Total # of neighbors = 121020
Ave neighs/atom = 60.51
Neighbor list builds = 23
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.44283101317, Press = -3.7073779702755
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -3123.8873     -3123.8873     -3205.508      -3205.508       315.88028      315.88028      44818.633      44818.633      58.335697      58.335697    
     31000  -3122.7778     -3122.7778     -3203.4739     -3203.4739      312.30232      312.30232      44716.159      44716.159      474.14663      474.14663    
Loop time of 202.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.233 hours/ns, 4.940 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.29     | 201.29     | 201.29     |   0.0 | 99.43
Neigh   | 0.54138    | 0.54138    | 0.54138    |   0.0 |  0.27
Comm    | 0.10317    | 0.10317    | 0.10317    |   0.0 |  0.05
Output  | 0.00021223 | 0.00021223 | 0.00021223 |   0.0 |  0.00
Modify  | 0.44673    | 0.44673    | 0.44673    |   0.0 |  0.22
Other   |            | 0.06062    |            |       |  0.03

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

Total # of neighbors = 121124
Ave neighs/atom = 60.562
Neighbor list builds = 23
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.416491450074, Press = -1.57158927252285
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -3122.7778     -3122.7778     -3203.4739     -3203.4739      312.30232      312.30232      44716.159      44716.159      474.14663      474.14663    
     32000  -3129.2074     -3129.2074     -3210.9695     -3210.9695      316.42765      316.42765      44589.019      44589.019      467.44998      467.44998    
Loop time of 202.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.242 hours/ns, 4.939 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.32     | 201.32     | 201.32     |   0.0 | 99.43
Neigh   | 0.5409     | 0.5409     | 0.5409     |   0.0 |  0.27
Comm    | 0.10264    | 0.10264    | 0.10264    |   0.0 |  0.05
Output  | 0.00016913 | 0.00016913 | 0.00016913 |   0.0 |  0.00
Modify  | 0.44249    | 0.44249    | 0.44249    |   0.0 |  0.22
Other   |            | 0.06096    |            |       |  0.03

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

Total # of neighbors = 121494
Ave neighs/atom = 60.747
Neighbor list builds = 23
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.471808569021, Press = 0.965351419039447
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -3129.2074     -3129.2074     -3210.9695     -3210.9695      316.42765      316.42765      44589.019      44589.019      467.44998      467.44998    
     33000  -3125.3326     -3125.3326     -3205.5306     -3205.5306      310.37452      310.37452      44972.328      44972.328     -250.55801     -250.55801    
Loop time of 202.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.129 hours/ns, 4.949 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.91     | 200.91     | 200.91     |   0.0 | 99.43
Neigh   | 0.56423    | 0.56423    | 0.56423    |   0.0 |  0.28
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.05
Output  | 0.00016777 | 0.00016777 | 0.00016777 |   0.0 |  0.00
Modify  | 0.43211    | 0.43211    | 0.43211    |   0.0 |  0.21
Other   |            | 0.06041    |            |       |  0.03

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

Total # of neighbors = 120986
Ave neighs/atom = 60.493
Neighbor list builds = 24
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.389360747078, Press = -0.185994581564486
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -3125.3326     -3125.3326     -3205.5306     -3205.5306      310.37452      310.37452      44972.328      44972.328     -250.55801     -250.55801    
     34000  -3128.7261     -3128.7261     -3207.708      -3207.708       305.66791      305.66791      44862.802      44862.802     -109.23274     -109.23274    
Loop time of 201.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.058 hours/ns, 4.955 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.65     | 200.65     | 200.65     |   0.0 | 99.42
Neigh   | 0.56018    | 0.56018    | 0.56018    |   0.0 |  0.28
Comm    | 0.10191    | 0.10191    | 0.10191    |   0.0 |  0.05
Output  | 0.00022911 | 0.00022911 | 0.00022911 |   0.0 |  0.00
Modify  | 0.43894    | 0.43894    | 0.43894    |   0.0 |  0.22
Other   |            | 0.06039    |            |       |  0.03

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

Total # of neighbors = 120904
Ave neighs/atom = 60.452
Neighbor list builds = 24
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.440259025572, Press = -1.80669209323276
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -3128.7261     -3128.7261     -3207.708      -3207.708       305.66791      305.66791      44862.802      44862.802     -109.23274     -109.23274    
     35000  -3124.7682     -3124.7682     -3206.7824     -3206.7824      317.40321      317.40321      44811.932      44811.932      115.22306      115.22306    
Loop time of 202.082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.134 hours/ns, 4.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.92     | 200.92     | 200.92     |   0.0 | 99.42
Neigh   | 0.56201    | 0.56201    | 0.56201    |   0.0 |  0.28
Comm    | 0.10244    | 0.10244    | 0.10244    |   0.0 |  0.05
Output  | 0.00019795 | 0.00019795 | 0.00019795 |   0.0 |  0.00
Modify  | 0.44121    | 0.44121    | 0.44121    |   0.0 |  0.22
Other   |            | 0.06062    |            |       |  0.03

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

Total # of neighbors = 121156
Ave neighs/atom = 60.578
Neighbor list builds = 24
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.416570662479, Press = -2.45932996648407
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -3124.7682     -3124.7682     -3206.7824     -3206.7824      317.40321      317.40321      44811.932      44811.932      115.22306      115.22306    
     36000  -3125.9678     -3125.9678     -3207.4809     -3207.4809      315.46438      315.46438      44721.012      44721.012      298.48585      298.48585    
Loop time of 202.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.207 hours/ns, 4.942 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.2      | 201.2      | 201.2      |   0.0 | 99.43
Neigh   | 0.5393     | 0.5393     | 0.5393     |   0.0 |  0.27
Comm    | 0.10258    | 0.10258    | 0.10258    |   0.0 |  0.05
Output  | 0.00022915 | 0.00022915 | 0.00022915 |   0.0 |  0.00
Modify  | 0.44257    | 0.44257    | 0.44257    |   0.0 |  0.22
Other   |            | 0.06097    |            |       |  0.03

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

Total # of neighbors = 121154
Ave neighs/atom = 60.577
Neighbor list builds = 23
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.348301136271, Press = -0.70398751576974
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3125.9678     -3125.9678     -3207.4809     -3207.4809      315.46438      315.46438      44721.012      44721.012      298.48585      298.48585    
     37000  -3120.4322     -3120.4322     -3204.8762     -3204.8762      326.80709      326.80709      44937.007      44937.007     -35.769881     -35.769881    
Loop time of 201.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.092 hours/ns, 4.952 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.76     | 200.76     | 200.76     |   0.0 | 99.42
Neigh   | 0.57079    | 0.57079    | 0.57079    |   0.0 |  0.28
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.05
Output  | 0.0001665  | 0.0001665  | 0.0001665  |   0.0 |  0.00
Modify  | 0.43965    | 0.43965    | 0.43965    |   0.0 |  0.22
Other   |            | 0.06041    |            |       |  0.03

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

Total # of neighbors = 121092
Ave neighs/atom = 60.546
Neighbor list builds = 24
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.425032322731, Press = 0.128104259598827
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3120.4322     -3120.4322     -3204.8762     -3204.8762      326.80709      326.80709      44937.007      44937.007     -35.769881     -35.769881    
     38000  -3126.524      -3126.524      -3206.6382     -3206.6382      310.04992      310.04992      44927.946      44927.946     -242.81682     -242.81682    
Loop time of 201.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.092 hours/ns, 4.952 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.77     | 200.77     | 200.77     |   0.0 | 99.42
Neigh   | 0.56325    | 0.56325    | 0.56325    |   0.0 |  0.28
Comm    | 0.10153    | 0.10153    | 0.10153    |   0.0 |  0.05
Output  | 0.00021276 | 0.00021276 | 0.00021276 |   0.0 |  0.00
Modify  | 0.43736    | 0.43736    | 0.43736    |   0.0 |  0.22
Other   |            | 0.06024    |            |       |  0.03

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

Total # of neighbors = 121082
Ave neighs/atom = 60.541
Neighbor list builds = 24
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.479190725349, Press = -0.471592938660654
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -3126.524      -3126.524      -3206.6382     -3206.6382      310.04992      310.04992      44927.946      44927.946     -242.81682     -242.81682    
     39000  -3124.1512     -3124.1512     -3206.0414     -3206.0414      316.92325      316.92325      45056.635      45056.635     -470.92541     -470.92541    
Loop time of 203.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.424 ns/day, 56.550 hours/ns, 4.912 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    | 202.4      | 202.4      | 202.4      |   0.0 | 99.42
Neigh   | 0.57111    | 0.57111    | 0.57111    |   0.0 |  0.28
Comm    | 0.10296    | 0.10296    | 0.10296    |   0.0 |  0.05
Output  | 0.0002108  | 0.0002108  | 0.0002108  |   0.0 |  0.00
Modify  | 0.44179    | 0.44179    | 0.44179    |   0.0 |  0.22
Other   |            | 0.06093    |            |       |  0.03

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

Total # of neighbors = 120984
Ave neighs/atom = 60.492
Neighbor list builds = 24
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.460884396886, Press = -1.21914815155562
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3124.1512     -3124.1512     -3206.0414     -3206.0414      316.92325      316.92325      45056.635      45056.635     -470.92541     -470.92541    
     40000  -3131.3321     -3131.3321     -3210.469      -3210.469       306.26798      306.26798      44776.432      44776.432      10.76037       10.76037     
Loop time of 200.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.431 ns/day, 55.631 hours/ns, 4.993 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.14     | 199.14     | 199.14     |   0.0 | 99.43
Neigh   | 0.53933    | 0.53933    | 0.53933    |   0.0 |  0.27
Comm    | 0.10174    | 0.10174    | 0.10174    |   0.0 |  0.05
Output  | 0.00016801 | 0.00016801 | 0.00016801 |   0.0 |  0.00
Modify  | 0.43344    | 0.43344    | 0.43344    |   0.0 |  0.22
Other   |            | 0.06101    |            |       |  0.03

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

Total # of neighbors = 121048
Ave neighs/atom = 60.524
Neighbor list builds = 23
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.431257579851, Press = -1.67025477452087
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3131.3321     -3131.3321     -3210.469      -3210.469       306.26798      306.26798      44776.432      44776.432      10.76037       10.76037     
     41000  -3123.9791     -3123.9791     -3205.4516     -3205.4516      315.30698      315.30698      44747.67       44747.67       282.02618      282.02618    
Loop time of 201.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.430 ns/day, 55.842 hours/ns, 4.974 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.88     | 199.88     | 199.88     |   0.0 | 99.42
Neigh   | 0.55956    | 0.55956    | 0.55956    |   0.0 |  0.28
Comm    | 0.10171    | 0.10171    | 0.10171    |   0.0 |  0.05
Output  | 0.00016731 | 0.00016731 | 0.00016731 |   0.0 |  0.00
Modify  | 0.43399    | 0.43399    | 0.43399    |   0.0 |  0.22
Other   |            | 0.06125    |            |       |  0.03

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

Total # of neighbors = 121250
Ave neighs/atom = 60.625
Neighbor list builds = 24
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.395696180864, Press = -1.06752073792295
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -3123.9791     -3123.9791     -3205.4516     -3205.4516      315.30698      315.30698      44747.67       44747.67       282.02618      282.02618    
     42000  -3123.6145     -3123.6145     -3204.9425     -3204.9425      314.74777      314.74777      44846.788      44846.788      122.22236      122.22236    
Loop time of 197.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.976 hours/ns, 5.053 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.76     | 196.76     | 196.76     |   0.0 | 99.42
Neigh   | 0.5625     | 0.5625     | 0.5625     |   0.0 |  0.28
Comm    | 0.10125    | 0.10125    | 0.10125    |   0.0 |  0.05
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.42838    | 0.42838    | 0.42838    |   0.0 |  0.22
Other   |            | 0.05945    |            |       |  0.03

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

Total # of neighbors = 121012
Ave neighs/atom = 60.506
Neighbor list builds = 24
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.350703446252, Press = -1.17601932360769
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3123.6145     -3123.6145     -3204.9425     -3204.9425      314.74777      314.74777      44846.788      44846.788      122.22236      122.22236    
     43000  -3130.4776     -3130.4776     -3208.8559     -3208.8559      303.33221      303.33221      44722.551      44722.551      192.70668      192.70668    
Loop time of 195.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.443 ns/day, 54.231 hours/ns, 5.122 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    | 194.12     | 194.12     | 194.12     |   0.0 | 99.43
Neigh   | 0.52821    | 0.52821    | 0.52821    |   0.0 |  0.27
Comm    | 0.10012    | 0.10012    | 0.10012    |   0.0 |  0.05
Output  | 0.00016868 | 0.00016868 | 0.00016868 |   0.0 |  0.00
Modify  | 0.42132    | 0.42132    | 0.42132    |   0.0 |  0.22
Other   |            | 0.05953    |            |       |  0.03

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

Total # of neighbors = 121068
Ave neighs/atom = 60.534
Neighbor list builds = 23
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.288150622934, Press = -1.00198911683869
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -3130.4776     -3130.4776     -3208.8559     -3208.8559      303.33221      303.33221      44722.551      44722.551      192.70668      192.70668    
     44000  -3124.5717     -3124.5717     -3207.7876     -3207.7876      322.05427      322.05427      44850.168      44850.168     -50.563253     -50.563253    
Loop time of 175.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.492 ns/day, 48.792 hours/ns, 5.693 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 174.64     | 174.64     | 174.64     |   0.0 | 99.42
Neigh   | 0.50232    | 0.50232    | 0.50232    |   0.0 |  0.29
Comm    | 0.090473   | 0.090473   | 0.090473   |   0.0 |  0.05
Output  | 0.0001668  | 0.0001668  | 0.0001668  |   0.0 |  0.00
Modify  | 0.36336    | 0.36336    | 0.36336    |   0.0 |  0.21
Other   |            | 0.05561    |            |       |  0.03

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

Total # of neighbors = 121046
Ave neighs/atom = 60.523
Neighbor list builds = 23
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.275493589643, Press = -0.557174851100628
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -3124.5717     -3124.5717     -3207.7876     -3207.7876      322.05427      322.05427      44850.168      44850.168     -50.563253     -50.563253    
     45000  -3124.3916     -3124.3916     -3207.0064     -3207.0064      319.72802      319.72802      44979.851      44979.851     -287.20204     -287.20204    
Loop time of 181.111 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.477 ns/day, 50.309 hours/ns, 5.521 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    | 180.05     | 180.05     | 180.05     |   0.0 | 99.41
Neigh   | 0.53191    | 0.53191    | 0.53191    |   0.0 |  0.29
Comm    | 0.094558   | 0.094558   | 0.094558   |   0.0 |  0.05
Output  | 0.00048448 | 0.00048448 | 0.00048448 |   0.0 |  0.00
Modify  | 0.37819    | 0.37819    | 0.37819    |   0.0 |  0.21
Other   |            | 0.05619    |            |       |  0.03

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

Total # of neighbors = 120988
Ave neighs/atom = 60.494
Neighbor list builds = 24
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.226636160606, Press = -0.522796009591086
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3124.3916     -3124.3916     -3207.0064     -3207.0064      319.72802      319.72802      44979.851      44979.851     -287.20204     -287.20204    
     46000  -3126.9113     -3126.9113     -3206.2735     -3206.2735      307.1402       307.1402       45123.329      45123.329     -702.20133     -702.20133    
Loop time of 173.187 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.107 hours/ns, 5.774 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 172.17     | 172.17     | 172.17     |   0.0 | 99.41
Neigh   | 0.51777    | 0.51777    | 0.51777    |   0.0 |  0.30
Comm    | 0.089915   | 0.089915   | 0.089915   |   0.0 |  0.05
Output  | 0.00016732 | 0.00016732 | 0.00016732 |   0.0 |  0.00
Modify  | 0.35558    | 0.35558    | 0.35558    |   0.0 |  0.21
Other   |            | 0.05539    |            |       |  0.03

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

Total # of neighbors = 120986
Ave neighs/atom = 60.493
Neighbor list builds = 24
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.191043490509, Press = -0.316099169653585
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -3126.9113     -3126.9113     -3206.2735     -3206.2735      307.1402       307.1402       45123.329      45123.329     -702.20133     -702.20133    
     47000  -3121.2928     -3121.2928     -3205.5387     -3205.5387      326.04017      326.04017      44999.425      44999.425     -226.64665     -226.64665    
Loop time of 172.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.026 hours/ns, 5.784 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.87     | 171.87     | 171.87     |   0.0 | 99.41
Neigh   | 0.5185     | 0.5185     | 0.5185     |   0.0 |  0.30
Comm    | 0.089581   | 0.089581   | 0.089581   |   0.0 |  0.05
Output  | 0.00020325 | 0.00020325 | 0.00020325 |   0.0 |  0.00
Modify  | 0.35669    | 0.35669    | 0.35669    |   0.0 |  0.21
Other   |            | 0.05546    |            |       |  0.03

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

Total # of neighbors = 120968
Ave neighs/atom = 60.484
Neighbor list builds = 24
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.2177622036, Press = -1.01254015819385
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -3121.2928     -3121.2928     -3205.5387     -3205.5387      326.04017      326.04017      44999.425      44999.425     -226.64665     -226.64665    
     48000  -3126.5482     -3126.5482     -3209.4433     -3209.4433      320.81261      320.81261      44895.16       44895.16      -162.44521     -162.44521    
Loop time of 172.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.500 ns/day, 48.000 hours/ns, 5.787 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 171.8      | 171.8      | 171.8      |   0.0 | 99.42
Neigh   | 0.49619    | 0.49619    | 0.49619    |   0.0 |  0.29
Comm    | 0.089382   | 0.089382   | 0.089382   |   0.0 |  0.05
Output  | 0.0001695  | 0.0001695  | 0.0001695  |   0.0 |  0.00
Modify  | 0.35575    | 0.35575    | 0.35575    |   0.0 |  0.21
Other   |            | 0.05543    |            |       |  0.03

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

Total # of neighbors = 120804
Ave neighs/atom = 60.402
Neighbor list builds = 23
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.24641111717, Press = -0.912499914941641
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -3126.5482     -3126.5482     -3209.4433     -3209.4433      320.81261      320.81261      44895.16       44895.16      -162.44521     -162.44521    
     49000  -3121.0078     -3121.0078     -3205.2562     -3205.2562      326.05001      326.05001      45070.933      45070.933     -411.80342     -411.80342    
Loop time of 191.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.452 ns/day, 53.149 hours/ns, 5.226 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 190.21     | 190.21     | 190.21     |   0.0 | 99.41
Neigh   | 0.55181    | 0.55181    | 0.55181    |   0.0 |  0.29
Comm    | 0.099679   | 0.099679   | 0.099679   |   0.0 |  0.05
Output  | 0.00025715 | 0.00025715 | 0.00025715 |   0.0 |  0.00
Modify  | 0.41531    | 0.41531    | 0.41531    |   0.0 |  0.22
Other   |            | 0.05985    |            |       |  0.03

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

Total # of neighbors = 120902
Ave neighs/atom = 60.451
Neighbor list builds = 24
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.286221611456, Press = -1.45760812048153
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -3121.0078     -3121.0078     -3205.2562     -3205.2562      326.05001      326.05001      45070.933      45070.933     -411.80342     -411.80342    
     50000  -3125.7957     -3125.7957     -3206.8039     -3206.8039      313.51008      313.51008      44814.104      44814.104      41.630686      41.630686    
Loop time of 201.743 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.428 ns/day, 56.040 hours/ns, 4.957 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    | 200.6      | 200.6      | 200.6      |   0.0 | 99.43
Neigh   | 0.54119    | 0.54119    | 0.54119    |   0.0 |  0.27
Comm    | 0.10194    | 0.10194    | 0.10194    |   0.0 |  0.05
Output  | 0.00020966 | 0.00020966 | 0.00020966 |   0.0 |  0.00
Modify  | 0.43773    | 0.43773    | 0.43773    |   0.0 |  0.22
Other   |            | 0.06093    |            |       |  0.03

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

Total # of neighbors = 121064
Ave neighs/atom = 60.532
Neighbor list builds = 23
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.3144378801, Press = -1.77153208202731
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -3125.7957     -3125.7957     -3206.8039     -3206.8039      313.51008      313.51008      44814.104      44814.104      41.630686      41.630686    
     51000  -3122.156      -3122.156      -3207.4283     -3207.4283      330.01239      330.01239      44640.486      44640.486      641.54926      641.54926    
Loop time of 202.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.427 ns/day, 56.235 hours/ns, 4.940 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.27     | 201.27     | 201.27     |   0.0 | 99.42
Neigh   | 0.56548    | 0.56548    | 0.56548    |   0.0 |  0.28
Comm    | 0.10337    | 0.10337    | 0.10337    |   0.0 |  0.05
Output  | 0.00016727 | 0.00016727 | 0.00016727 |   0.0 |  0.00
Modify  | 0.4445     | 0.4445     | 0.4445     |   0.0 |  0.22
Other   |            | 0.0609     |            |       |  0.03

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

Total # of neighbors = 121246
Ave neighs/atom = 60.623
Neighbor list builds = 24
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.297103550204, Press = -0.589130357157039
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -3122.156      -3122.156      -3207.4283     -3207.4283      330.01239      330.01239      44640.486      44640.486      641.54926      641.54926    
     52000  -3128.4367     -3128.4367     -3211.1184     -3211.1184      319.98674      319.98674      44717.654      44717.654      172.63599      172.63599    
Loop time of 203.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.425 ns/day, 56.511 hours/ns, 4.915 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 202.25     | 202.25     | 202.25     |   0.0 | 99.41
Neigh   | 0.59178    | 0.59178    | 0.59178    |   0.0 |  0.29
Comm    | 0.1038     | 0.1038     | 0.1038     |   0.0 |  0.05
Output  | 0.00023288 | 0.00023288 | 0.00023288 |   0.0 |  0.00
Modify  | 0.43904    | 0.43904    | 0.43904    |   0.0 |  0.22
Other   |            | 0.06111    |            |       |  0.03

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

Total # of neighbors = 121122
Ave neighs/atom = 60.561
Neighbor list builds = 25
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.343369053819, Press = 0.403768214460091
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -3128.4367     -3128.4367     -3211.1184     -3211.1184      319.98674      319.98674      44717.654      44717.654      172.63599      172.63599    
     53000  -3125.0169     -3125.0169     -3204.854      -3204.854       308.97769      308.97769      45072.688      45072.688     -478.66873     -478.66873    
Loop time of 202.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.426 ns/day, 56.387 hours/ns, 4.926 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 201.82     | 201.82     | 201.82     |   0.0 | 99.42
Neigh   | 0.56542    | 0.56542    | 0.56542    |   0.0 |  0.28
Comm    | 0.10369    | 0.10369    | 0.10369    |   0.0 |  0.05
Output  | 0.00016701 | 0.00016701 | 0.00016701 |   0.0 |  0.00
Modify  | 0.44543    | 0.44543    | 0.44543    |   0.0 |  0.22
Other   |            | 0.06079    |            |       |  0.03

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

Total # of neighbors = 120780
Ave neighs/atom = 60.39
Neighbor list builds = 24
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.286850379482, Press = -0.317061150284684
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -3125.0169     -3125.0169     -3204.854      -3204.854       308.97769      308.97769      45072.688      45072.688     -478.66873     -478.66873    
     54000  -3129.0701     -3129.0701     -3207.9109     -3207.9109      305.12216      305.12216      44888.058      44888.058     -199.36569     -199.36569    
Loop time of 193.073 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.447 ns/day, 53.631 hours/ns, 5.179 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    | 191.97     | 191.97     | 191.97     |   0.0 | 99.43
Neigh   | 0.52765    | 0.52765    | 0.52765    |   0.0 |  0.27
Comm    | 0.0986     | 0.0986     | 0.0986     |   0.0 |  0.05
Output  | 0.00017067 | 0.00017067 | 0.00017067 |   0.0 |  0.00
Modify  | 0.41722    | 0.41722    | 0.41722    |   0.0 |  0.22
Other   |            | 0.05929    |            |       |  0.03

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

Total # of neighbors = 120974
Ave neighs/atom = 60.487
Neighbor list builds = 23
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.237370383939, Press = -0.763325307381303
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -3129.0701     -3129.0701     -3207.9109     -3207.9109      305.12216      305.12216      44888.058      44888.058     -199.36569     -199.36569    
     55000  -3128.4205     -3128.4205     -3210.3583     -3210.3583      317.10764      317.10764      44721.188      44721.188      230.34456      230.34456    
Loop time of 177.245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.487 ns/day, 49.235 hours/ns, 5.642 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 176.21     | 176.21     | 176.21     |   0.0 | 99.41
Neigh   | 0.52505    | 0.52505    | 0.52505    |   0.0 |  0.30
Comm    | 0.092075   | 0.092075   | 0.092075   |   0.0 |  0.05
Output  | 0.00016841 | 0.00016841 | 0.00016841 |   0.0 |  0.00
Modify  | 0.36604    | 0.36604    | 0.36604    |   0.0 |  0.21
Other   |            | 0.05548    |            |       |  0.03

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

Total # of neighbors = 121114
Ave neighs/atom = 60.557
Neighbor list builds = 24
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.246956387008, Press = -1.49176956748269
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 = 11 11 11
  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.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -3128.4205     -3128.4205     -3210.3583     -3210.3583      317.10764      317.10764      44721.188      44721.188      230.34456      230.34456    
     56000  -3126.3471     -3126.3471     -3206.8509     -3206.8509      311.55809      311.55809      44747.235      44747.235      270.52627      270.52627    
Loop time of 180.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.086 hours/ns, 5.546 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 179.28     | 179.28     | 179.28     |   0.0 | 99.43
Neigh   | 0.50877    | 0.50877    | 0.50877    |   0.0 |  0.28
Comm    | 0.092331   | 0.092331   | 0.092331   |   0.0 |  0.05
Output  | 0.00016937 | 0.00016937 | 0.00016937 |   0.0 |  0.00
Modify  | 0.37613    | 0.37613    | 0.37613    |   0.0 |  0.21
Other   |            | 0.05674    |            |       |  0.03

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

Total # of neighbors = 121100
Ave neighs/atom = 60.55
Neighbor list builds = 23
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.195828946978, Press = -0.714352294398977
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 = 11 11 11
  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.704 | 3.704 | 3.704 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -3126.3471     -3126.3471     -3206.8509     -3206.8509      311.55809      311.55809      44747.235      44747.235      270.52627      270.52627    
     57000  -3120.118      -3120.118      -3204.392      -3204.392       326.14928      326.14928      44878.363      44878.363      140.86624      140.86624    
Loop time of 200.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.432 ns/day, 55.566 hours/ns, 4.999 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.88     | 198.88     | 198.88     |   0.0 | 99.42
Neigh   | 0.55563    | 0.55563    | 0.55563    |   0.0 |  0.28
Comm    | 0.10234    | 0.10234    | 0.10234    |   0.0 |  0.05
Output  | 0.00020832 | 0.00020832 | 0.00020832 |   0.0 |  0.00
Modify  | 0.43722    | 0.43722    | 0.43722    |   0.0 |  0.22
Other   |            | 0.06058    |            |       |  0.03

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

Total # of neighbors = 121112
Ave neighs/atom = 60.556
Neighbor list builds = 24
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
44845.4370583352

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0