# 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 4.049998879432679*${_u_distance}
variable latticeconst_converted equal 4.049998879432679*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04999887943268
Lattice spacing in x,y,z = 4.0499989 4.0499989 4.0499989
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.499989 40.499989 40.499989)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.499989 40.499989 40.499989)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_PascuetFernandez_2015_Al__MO_315820974149_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0698596988 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_315820974149_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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13288.427     -13288.427     -13439.96      -13439.96       293.15         293.15         66430.07       66430.07       2436.4703      2436.4703    
      1000  -13113.188     -13113.188     -13270.562     -13270.562      304.45098      304.45098      68076.303      68076.303     -527.2093      -527.2093     
Loop time of 36.0186 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.399 ns/day, 10.005 hours/ns, 27.763 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 35.854     | 35.854     | 35.854     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02371    | 0.02371    | 0.02371    |   0.0 |  0.07
Output  | 0.00013878 | 0.00013878 | 0.00013878 |   0.0 |  0.00
Modify  | 0.12648    | 0.12648    | 0.12648    |   0.0 |  0.35
Other   |            | 0.01412    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13113.188     -13113.188     -13270.562     -13270.562      304.45098      304.45098      68076.303      68076.303     -527.2093      -527.2093     
      2000  -13131.578     -13131.578     -13279.787     -13279.787      286.72093      286.72093      67880.454      67880.454      441.73106      441.73106    
Loop time of 38.4907 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.245 ns/day, 10.692 hours/ns, 25.980 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.333     | 38.333     | 38.333     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022603   | 0.022603   | 0.022603   |   0.0 |  0.06
Output  | 0.00010185 | 0.00010185 | 0.00010185 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  0.32
Other   |            | 0.01249    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320364 ave      320364 max      320364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320364
Ave neighs/atom = 80.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13131.578     -13131.578     -13279.787     -13279.787      286.72093      286.72093      67880.454      67880.454      441.73106      441.73106    
      3000  -13122.272     -13122.272     -13273.816     -13273.816      293.17219      293.17219      67966.348      67966.348      183.1851       183.1851     
Loop time of 37.6675 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.294 ns/day, 10.463 hours/ns, 26.548 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.515     | 37.515     | 37.515     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02189    | 0.02189    | 0.02189    |   0.0 |  0.06
Output  | 8.4519e-05 | 8.4519e-05 | 8.4519e-05 |   0.0 |  0.00
Modify  | 0.11909    | 0.11909    | 0.11909    |   0.0 |  0.32
Other   |            | 0.01163    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320682 ave      320682 max      320682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320682
Ave neighs/atom = 80.1705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13122.272     -13122.272     -13273.816     -13273.816      293.17219      293.17219      67966.348      67966.348      183.1851       183.1851     
      4000  -13128.516     -13128.516     -13279.702     -13279.702      292.48085      292.48085      67966.024      67966.024     -343.14234     -343.14234    
Loop time of 38.3112 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.255 ns/day, 10.642 hours/ns, 26.102 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.155     | 38.155     | 38.155     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02231    | 0.02231    | 0.02231    |   0.0 |  0.06
Output  | 9.4539e-05 | 9.4539e-05 | 9.4539e-05 |   0.0 |  0.00
Modify  | 0.12208    | 0.12208    | 0.12208    |   0.0 |  0.32
Other   |            | 0.01176    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320588 ave      320588 max      320588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320588
Ave neighs/atom = 80.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13128.516     -13128.516     -13279.702     -13279.702      292.48085      292.48085      67966.024      67966.024     -343.14234     -343.14234    
      5000  -13121.865     -13121.865     -13275.129     -13275.129      296.50067      296.50067      67913.626      67913.626      565.03004      565.03004    
Loop time of 38.4327 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.248 ns/day, 10.676 hours/ns, 26.019 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 38.266     | 38.266     | 38.266     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023673   | 0.023673   | 0.023673   |   0.0 |  0.06
Output  | 7.91e-05   | 7.91e-05   | 7.91e-05   |   0.0 |  0.00
Modify  | 0.12736    | 0.12736    | 0.12736    |   0.0 |  0.33
Other   |            | 0.01569    |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320638 ave      320638 max      320638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320638
Ave neighs/atom = 80.1595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 296.469444914006, Press = -46.4370770194251
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13121.865     -13121.865     -13275.129     -13275.129      296.50067      296.50067      67913.626      67913.626      565.03004      565.03004    
      6000  -13129.152     -13129.152     -13280.274     -13280.274      292.35563      292.35563      68041.2        68041.2       -1093.2565     -1093.2565    
Loop time of 37.7825 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.287 ns/day, 10.495 hours/ns, 26.467 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.616     | 37.616     | 37.616     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023033   | 0.023033   | 0.023033   |   0.0 |  0.06
Output  | 8.2095e-05 | 8.2095e-05 | 8.2095e-05 |   0.0 |  0.00
Modify  | 0.12956    | 0.12956    | 0.12956    |   0.0 |  0.34
Other   |            | 0.0136     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320748 ave      320748 max      320748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320748
Ave neighs/atom = 80.187
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.183152624458, Press = -13.2858155350303
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13129.152     -13129.152     -13280.274     -13280.274      292.35563      292.35563      68041.2        68041.2       -1093.2565     -1093.2565    
      7000  -13123.513     -13123.513     -13278.03      -13278.03       298.9244       298.9244       67904.83       67904.83       445.14984      445.14984    
Loop time of 37.7487 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.486 hours/ns, 26.491 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.59      | 37.59      | 37.59      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022092   | 0.022092   | 0.022092   |   0.0 |  0.06
Output  | 4.6708e-05 | 4.6708e-05 | 4.6708e-05 |   0.0 |  0.00
Modify  | 0.12472    | 0.12472    | 0.12472    |   0.0 |  0.33
Other   |            | 0.01178    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320396 ave      320396 max      320396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320396
Ave neighs/atom = 80.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.370429673149, Press = 18.0301150027856
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13123.513     -13123.513     -13278.03      -13278.03       298.9244       298.9244       67904.83       67904.83       445.14984      445.14984    
      8000  -13127.142     -13127.142     -13277.665     -13277.665      291.19615      291.19615      67948.661      67948.661     -18.188125     -18.188125    
Loop time of 37.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.475 hours/ns, 26.517 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.554     | 37.554     | 37.554     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022013   | 0.022013   | 0.022013   |   0.0 |  0.06
Output  | 8.2766e-05 | 8.2766e-05 | 8.2766e-05 |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.33
Other   |            | 0.01132    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320736 ave      320736 max      320736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320736
Ave neighs/atom = 80.184
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.158723368084, Press = -13.2273426204122
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13127.142     -13127.142     -13277.665     -13277.665      291.19615      291.19615      67948.661      67948.661     -18.188125     -18.188125    
      9000  -13124.419     -13124.419     -13276.154     -13276.154      293.54042      293.54042      67990.181      67990.181     -226.48604     -226.48604    
Loop time of 37.7078 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.520 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.551     | 37.551     | 37.551     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022119   | 0.022119   | 0.022119   |   0.0 |  0.06
Output  | 3.4034e-05 | 3.4034e-05 | 3.4034e-05 |   0.0 |  0.00
Modify  | 0.12306    | 0.12306    | 0.12306    |   0.0 |  0.33
Other   |            | 0.01135    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320664 ave      320664 max      320664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320664
Ave neighs/atom = 80.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.912119878964, Press = 4.79227795848227
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13124.419     -13124.419     -13276.154     -13276.154      293.54042      293.54042      67990.181      67990.181     -226.48604     -226.48604    
     10000  -13132.72      -13132.72      -13281.509     -13281.509      287.84221      287.84221      67846.888      67846.888      631.80836      631.80836    
Loop time of 37.7346 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.290 ns/day, 10.482 hours/ns, 26.501 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.577     | 37.577     | 37.577     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022285   | 0.022285   | 0.022285   |   0.0 |  0.06
Output  | 5.4433e-05 | 5.4433e-05 | 5.4433e-05 |   0.0 |  0.00
Modify  | 0.12391    | 0.12391    | 0.12391    |   0.0 |  0.33
Other   |            | 0.01141    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320592 ave      320592 max      320592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320592
Ave neighs/atom = 80.148
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.613615728036, Press = -1.45738518317229
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13132.72      -13132.72      -13281.509     -13281.509      287.84221      287.84221      67846.888      67846.888      631.80836      631.80836    
     11000  -13126.05      -13126.05      -13274.58      -13274.58       287.34149      287.34149      68004.011      68004.011     -302.94985     -302.94985    
Loop time of 37.7798 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.287 ns/day, 10.494 hours/ns, 26.469 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.625     | 37.625     | 37.625     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021828   | 0.021828   | 0.021828   |   0.0 |  0.06
Output  | 5.1397e-05 | 5.1397e-05 | 5.1397e-05 |   0.0 |  0.00
Modify  | 0.12206    | 0.12206    | 0.12206    |   0.0 |  0.32
Other   |            | 0.01116    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320860 ave      320860 max      320860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320860
Ave neighs/atom = 80.215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.555295936559, Press = 0.770863908031701
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13126.05      -13126.05      -13274.58      -13274.58       287.34149      287.34149      68004.011      68004.011     -302.94985     -302.94985    
     12000  -13128.038     -13128.038     -13278.589     -13278.589      291.25154      291.25154      67864.16       67864.16       769.32194      769.32194    
Loop time of 37.6536 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.295 ns/day, 10.459 hours/ns, 26.558 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    | 37.499     | 37.499     | 37.499     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021798   | 0.021798   | 0.021798   |   0.0 |  0.06
Output  | 3.0036e-05 | 3.0036e-05 | 3.0036e-05 |   0.0 |  0.00
Modify  | 0.12189    | 0.12189    | 0.12189    |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320370 ave      320370 max      320370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320370
Ave neighs/atom = 80.0925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.432714757886, Press = 1.08095891779444
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13128.038     -13128.038     -13278.589     -13278.589      291.25154      291.25154      67864.16       67864.16       769.32194      769.32194    
     13000  -13124.963     -13124.963     -13275.909     -13275.909      292.01555      292.01555      68037.618      68037.618     -763.05428     -763.05428    
Loop time of 37.6703 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.294 ns/day, 10.464 hours/ns, 26.546 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    | 37.515     | 37.515     | 37.515     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.06
Output  | 5.0776e-05 | 5.0776e-05 | 5.0776e-05 |   0.0 |  0.00
Modify  | 0.12202    | 0.12202    | 0.12202    |   0.0 |  0.32
Other   |            | 0.01114    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320780 ave      320780 max      320780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320780
Ave neighs/atom = 80.195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.556119581483, Press = -3.35101608342258
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13124.963     -13124.963     -13275.909     -13275.909      292.01555      292.01555      68037.618      68037.618     -763.05428     -763.05428    
     14000  -13126.464     -13126.464     -13278.119     -13278.119      293.38739      293.38739      67884.376      67884.376      641.64471      641.64471    
Loop time of 37.7589 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.288 ns/day, 10.489 hours/ns, 26.484 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    | 37.604     | 37.604     | 37.604     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021653   | 0.021653   | 0.021653   |   0.0 |  0.06
Output  | 8.2585e-05 | 8.2585e-05 | 8.2585e-05 |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320266 ave      320266 max      320266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320266
Ave neighs/atom = 80.0665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.604603950062, Press = 5.4964521901848
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13126.464     -13126.464     -13278.119     -13278.119      293.38739      293.38739      67884.376      67884.376      641.64471      641.64471    
     15000  -13130.59      -13130.59      -13280.447     -13280.447      289.90813      289.90813      67902.831      67902.831      154.09439      154.09439    
Loop time of 37.6821 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.293 ns/day, 10.467 hours/ns, 26.538 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    | 37.527     | 37.527     | 37.527     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.06
Output  | 2.9937e-05 | 2.9937e-05 | 2.9937e-05 |   0.0 |  0.00
Modify  | 0.1218     | 0.1218     | 0.1218     |   0.0 |  0.32
Other   |            | 0.01114    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320748 ave      320748 max      320748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320748
Ave neighs/atom = 80.187
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.610810953901, Press = -3.37768283254652
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13130.59      -13130.59      -13280.447     -13280.447      289.90813      289.90813      67902.831      67902.831      154.09439      154.09439    
     16000  -13123.498     -13123.498     -13276.35      -13276.35       295.7028       295.7028       67984.242      67984.242     -180.13622     -180.13622    
Loop time of 37.7196 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.478 hours/ns, 26.511 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    | 37.565     | 37.565     | 37.565     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021791   | 0.021791   | 0.021791   |   0.0 |  0.06
Output  | 5.1367e-05 | 5.1367e-05 | 5.1367e-05 |   0.0 |  0.00
Modify  | 0.12176    | 0.12176    | 0.12176    |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320792 ave      320792 max      320792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320792
Ave neighs/atom = 80.198
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.642656111244, Press = 1.92390754763613
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13123.498     -13123.498     -13276.35      -13276.35       295.7028       295.7028       67984.242      67984.242     -180.13622     -180.13622    
     17000  -13129.29      -13129.29      -13278.467     -13278.467      288.59317      288.59317      67908.784      67908.784      360.84559      360.84559    
Loop time of 37.7094 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.475 hours/ns, 26.519 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    | 37.555     | 37.555     | 37.555     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021725   | 0.021725   | 0.021725   |   0.0 |  0.06
Output  | 3.0037e-05 | 3.0037e-05 | 3.0037e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.32
Other   |            | 0.01116    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320470 ave      320470 max      320470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320470
Ave neighs/atom = 80.1175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.713598351822, Press = 0.326976828686002
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13129.29      -13129.29      -13278.467     -13278.467      288.59317      288.59317      67908.784      67908.784      360.84559      360.84559    
     18000  -13125.425     -13125.425     -13276.825     -13276.825      292.89394      292.89394      67973.689      67973.689     -108.56665     -108.56665    
Loop time of 37.6737 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.293 ns/day, 10.465 hours/ns, 26.544 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    | 37.519     | 37.519     | 37.519     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021733   | 0.021733   | 0.021733   |   0.0 |  0.06
Output  | 5.1386e-05 | 5.1386e-05 | 5.1386e-05 |   0.0 |  0.00
Modify  | 0.1218     | 0.1218     | 0.1218     |   0.0 |  0.32
Other   |            | 0.01117    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320794 ave      320794 max      320794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320794
Ave neighs/atom = 80.1985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708846251417, Press = 0.523311577875079
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13125.425     -13125.425     -13276.825     -13276.825      292.89394      292.89394      67973.689      67973.689     -108.56665     -108.56665    
     19000  -13125.16      -13125.16      -13278.14      -13278.14       295.95099      295.95099      67917.634      67917.634      336.41101      336.41101    
Loop time of 37.7072 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.520 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    | 37.552     | 37.552     | 37.552     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021716   | 0.021716   | 0.021716   |   0.0 |  0.06
Output  | 5.0565e-05 | 5.0565e-05 | 5.0565e-05 |   0.0 |  0.00
Modify  | 0.12191    | 0.12191    | 0.12191    |   0.0 |  0.32
Other   |            | 0.01117    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320722 ave      320722 max      320722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320722
Ave neighs/atom = 80.1805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.59016638691, Press = -0.19237233889833
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13125.16      -13125.16      -13278.14      -13278.14       295.95099      295.95099      67917.634      67917.634      336.41101      336.41101    
     20000  -13127.676     -13127.676     -13281.287     -13281.287      297.17144      297.17144      68003.018      68003.018     -802.55993     -802.55993    
Loop time of 37.6578 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.294 ns/day, 10.461 hours/ns, 26.555 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    | 37.503     | 37.503     | 37.503     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021768   | 0.021768   | 0.021768   |   0.0 |  0.06
Output  | 3.0197e-05 | 3.0197e-05 | 3.0197e-05 |   0.0 |  0.00
Modify  | 0.12182    | 0.12182    | 0.12182    |   0.0 |  0.32
Other   |            | 0.01111    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320730 ave      320730 max      320730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320730
Ave neighs/atom = 80.1825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.619897060488, Press = 0.624045983550098
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13127.676     -13127.676     -13281.287     -13281.287      297.17144      297.17144      68003.018      68003.018     -802.55993     -802.55993    
     21000  -13127.524     -13127.524     -13279.646     -13279.646      294.29106      294.29106      67847.293      67847.293      797.3204       797.3204     
Loop time of 37.7516 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.487 hours/ns, 26.489 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.597     | 37.597     | 37.597     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021737   | 0.021737   | 0.021737   |   0.0 |  0.06
Output  | 5.1567e-05 | 5.1567e-05 | 5.1567e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320492 ave      320492 max      320492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320492
Ave neighs/atom = 80.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.622556105274, Press = 0.632214317106595
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13127.524     -13127.524     -13279.646     -13279.646      294.29106      294.29106      67847.293      67847.293      797.3204       797.3204     
     22000  -13124.082     -13124.082     -13276.485     -13276.485      294.83305      294.83305      68054.683      68054.683     -964.80229     -964.80229    
Loop time of 37.7712 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.287 ns/day, 10.492 hours/ns, 26.475 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    | 37.617     | 37.617     | 37.617     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021673   | 0.021673   | 0.021673   |   0.0 |  0.06
Output  | 5.0204e-05 | 5.0204e-05 | 5.0204e-05 |   0.0 |  0.00
Modify  | 0.12183    | 0.12183    | 0.12183    |   0.0 |  0.32
Other   |            | 0.01114    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320850 ave      320850 max      320850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320850
Ave neighs/atom = 80.2125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.636402665588, Press = -0.486008090463584
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13124.082     -13124.082     -13276.485     -13276.485      294.83305      294.83305      68054.683      68054.683     -964.80229     -964.80229    
     23000  -13126.19      -13126.19      -13278.812     -13278.812      295.25762      295.25762      67850.081      67850.081      882.92679      882.92679    
Loop time of 37.6793 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.293 ns/day, 10.466 hours/ns, 26.540 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    | 37.525     | 37.525     | 37.525     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021715   | 0.021715   | 0.021715   |   0.0 |  0.06
Output  | 3.0528e-05 | 3.0528e-05 | 3.0528e-05 |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   0.0 |  0.32
Other   |            | 0.01112    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320248 ave      320248 max      320248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320248
Ave neighs/atom = 80.062
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.60779538017, Press = 1.2638545198383
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13126.19      -13126.19      -13278.812     -13278.812      295.25762      295.25762      67850.081      67850.081      882.92679      882.92679    
     24000  -13124.056     -13124.056     -13274.29      -13274.29       290.63839      290.63839      67984.811      67984.811     -139.16872     -139.16872    
Loop time of 37.6745 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.293 ns/day, 10.465 hours/ns, 26.543 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    | 37.52      | 37.52      | 37.52      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021719   | 0.021719   | 0.021719   |   0.0 |  0.06
Output  | 5.2459e-05 | 5.2459e-05 | 5.2459e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.32
Other   |            | 0.01111    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320988 ave      320988 max      320988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320988
Ave neighs/atom = 80.247
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.598632952863, Press = -0.382437003091861
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13124.056     -13124.056     -13274.29      -13274.29       290.63839      290.63839      67984.811      67984.811     -139.16872     -139.16872    
     25000  -13128.355     -13128.355     -13279.245     -13279.245      291.90736      291.90736      67924.029      67924.029      98.26811       98.26811     
Loop time of 37.7076 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.520 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    | 37.553     | 37.553     | 37.553     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021729   | 0.021729   | 0.021729   |   0.0 |  0.06
Output  | 3.0668e-05 | 3.0668e-05 | 3.0668e-05 |   0.0 |  0.00
Modify  | 0.12183    | 0.12183    | 0.12183    |   0.0 |  0.32
Other   |            | 0.01112    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320650 ave      320650 max      320650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320650
Ave neighs/atom = 80.1625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.595613429275, Press = 0.303164760887031
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13128.355     -13128.355     -13279.245     -13279.245      291.90736      291.90736      67924.029      67924.029      98.26811       98.26811     
     26000  -13124.983     -13124.983     -13277.446     -13277.446      294.95097      294.95097      67973.377      67973.377     -257.93517     -257.93517    
Loop time of 37.753 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.487 hours/ns, 26.488 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    | 37.598     | 37.598     | 37.598     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021868   | 0.021868   | 0.021868   |   0.0 |  0.06
Output  | 3.5156e-05 | 3.5156e-05 | 3.5156e-05 |   0.0 |  0.00
Modify  | 0.12183    | 0.12183    | 0.12183    |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320580 ave      320580 max      320580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320580
Ave neighs/atom = 80.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.569937269321, Press = 0.0301323561218302
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13124.983     -13124.983     -13277.446     -13277.446      294.95097      294.95097      67973.377      67973.377     -257.93517     -257.93517    
     27000  -13133.273     -13133.273     -13281.063     -13281.063      285.90887      285.90887      67851.854      67851.854      582.90149      582.90149    
Loop time of 37.7082 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.519 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    | 37.553     | 37.553     | 37.553     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021814   | 0.021814   | 0.021814   |   0.0 |  0.06
Output  | 4.9504e-05 | 4.9504e-05 | 4.9504e-05 |   0.0 |  0.00
Modify  | 0.12181    | 0.12181    | 0.12181    |   0.0 |  0.32
Other   |            | 0.01116    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320470 ave      320470 max      320470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320470
Ave neighs/atom = 80.1175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.574560087587, Press = 0.168128643100319
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13133.273     -13133.273     -13281.063     -13281.063      285.90887      285.90887      67851.854      67851.854      582.90149      582.90149    
     28000  -13125.19      -13125.19      -13277.896     -13277.896      295.41953      295.41953      68057.161      68057.161     -1069.0908     -1069.0908    
Loop time of 37.7497 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.486 hours/ns, 26.490 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    | 37.595     | 37.595     | 37.595     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021658   | 0.021658   | 0.021658   |   0.0 |  0.06
Output  | 3.0858e-05 | 3.0858e-05 | 3.0858e-05 |   0.0 |  0.00
Modify  | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.32
Other   |            | 0.01109    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320704 ave      320704 max      320704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320704
Ave neighs/atom = 80.176
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.534169928668, Press = -0.945975549612719
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13125.19      -13125.19      -13277.896     -13277.896      295.41953      295.41953      68057.161      68057.161     -1069.0908     -1069.0908    
     29000  -13130.645     -13130.645     -13280.632     -13280.632      290.16081      290.16081      67867.195      67867.195      520.13414      520.13414    
Loop time of 37.7242 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.290 ns/day, 10.479 hours/ns, 26.508 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    | 37.569     | 37.569     | 37.569     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021788   | 0.021788   | 0.021788   |   0.0 |  0.06
Output  | 5.6757e-05 | 5.6757e-05 | 5.6757e-05 |   0.0 |  0.00
Modify  | 0.12181    | 0.12181    | 0.12181    |   0.0 |  0.32
Other   |            | 0.01109    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320262 ave      320262 max      320262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320262
Ave neighs/atom = 80.0655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.510363505267, Press = 1.83100150902587
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13130.645     -13130.645     -13280.632     -13280.632      290.16081      290.16081      67867.195      67867.195      520.13414      520.13414    
     30000  -13124.642     -13124.642     -13276.676     -13276.676      294.12038      294.12038      67944.957      67944.957      91.830771      91.830771    
Loop time of 37.7487 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.486 hours/ns, 26.491 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    | 37.594     | 37.594     | 37.594     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021822   | 0.021822   | 0.021822   |   0.0 |  0.06
Output  | 5.304e-05  | 5.304e-05  | 5.304e-05  |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.32
Other   |            | 0.01115    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320712 ave      320712 max      320712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320712
Ave neighs/atom = 80.178
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.530648034503, Press = -1.11365093190756
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13124.642     -13124.642     -13276.676     -13276.676      294.12038      294.12038      67944.957      67944.957      91.830771      91.830771    
     31000  -13128.09      -13128.09      -13277.889     -13277.889      289.79757      289.79757      67984.01       67984.01      -428.97006     -428.97006    
Loop time of 37.7467 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.485 hours/ns, 26.492 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    | 37.592     | 37.592     | 37.592     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02174    | 0.02174    | 0.02174    |   0.0 |  0.06
Output  | 2.9877e-05 | 2.9877e-05 | 2.9877e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.32
Other   |            | 0.01114    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320588 ave      320588 max      320588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320588
Ave neighs/atom = 80.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.541302356107, Press = 0.527662554005477
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13128.09      -13128.09      -13277.889     -13277.889      289.79757      289.79757      67984.01       67984.01      -428.97006     -428.97006    
     32000  -13122.837     -13122.837     -13276.416     -13276.416      297.10823      297.10823      67917.437      67917.437      390.71894      390.71894    
Loop time of 37.7095 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.475 hours/ns, 26.519 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    | 37.555     | 37.555     | 37.555     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021696   | 0.021696   | 0.021696   |   0.0 |  0.06
Output  | 5.1437e-05 | 5.1437e-05 | 5.1437e-05 |   0.0 |  0.00
Modify  | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.32
Other   |            | 0.01113    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320364 ave      320364 max      320364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320364
Ave neighs/atom = 80.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.586062558769, Press = 0.253296721339687
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13122.837     -13122.837     -13276.416     -13276.416      297.10823      297.10823      67917.437      67917.437      390.71894      390.71894    
     33000  -13130.483     -13130.483     -13278.994     -13278.994      287.30572      287.30572      67997.726      67997.726     -670.16263     -670.16263    
Loop time of 37.7056 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.521 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    | 37.551     | 37.551     | 37.551     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022052   | 0.022052   | 0.022052   |   0.0 |  0.06
Output  | 3.9154e-05 | 3.9154e-05 | 3.9154e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.32
Other   |            | 0.01113    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320546 ave      320546 max      320546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320546
Ave neighs/atom = 80.1365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.567563395645, Press = -0.717283064929037
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13130.483     -13130.483     -13278.994     -13278.994      287.30572      287.30572      67997.726      67997.726     -670.16263     -670.16263    
     34000  -13124.579     -13124.579     -13277.064     -13277.064      294.99276      294.99276      67851.616      67851.616      982.11559      982.11559    
Loop time of 37.7095 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.475 hours/ns, 26.519 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    | 37.555     | 37.555     | 37.555     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021667   | 0.021667   | 0.021667   |   0.0 |  0.06
Output  | 3.0477e-05 | 3.0477e-05 | 3.0477e-05 |   0.0 |  0.00
Modify  | 0.12161    | 0.12161    | 0.12161    |   0.0 |  0.32
Other   |            | 0.01108    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320266 ave      320266 max      320266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320266
Ave neighs/atom = 80.0665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.550425045146, Press = 2.02192562901498
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13124.579     -13124.579     -13277.064     -13277.064      294.99276      294.99276      67851.616      67851.616      982.11559      982.11559    
     35000  -13129.325     -13129.325     -13278.496     -13278.496      288.58029      288.58029      67939.975      67939.975     -40.789222     -40.789222    
Loop time of 37.6923 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.292 ns/day, 10.470 hours/ns, 26.531 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    | 37.538     | 37.538     | 37.538     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02169    | 0.02169    | 0.02169    |   0.0 |  0.06
Output  | 5.1908e-05 | 5.1908e-05 | 5.1908e-05 |   0.0 |  0.00
Modify  | 0.12171    | 0.12171    | 0.12171    |   0.0 |  0.32
Other   |            | 0.01113    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       321022 ave      321022 max      321022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321022
Ave neighs/atom = 80.2555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.53412487819, Press = -1.05222298896009
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13129.325     -13129.325     -13278.496     -13278.496      288.58029      288.58029      67939.975      67939.975     -40.789222     -40.789222    
     36000  -13122.483     -13122.483     -13275.137     -13275.137      295.31917      295.31917      67974.826      67974.826     -14.142531     -14.142531    
Loop time of 37.7251 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.290 ns/day, 10.479 hours/ns, 26.508 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    | 37.57      | 37.57      | 37.57      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021871   | 0.021871   | 0.021871   |   0.0 |  0.06
Output  | 3.0538e-05 | 3.0538e-05 | 3.0538e-05 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.32
Other   |            | 0.01112    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320570 ave      320570 max      320570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320570
Ave neighs/atom = 80.1425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.571373285661, Press = 1.04426730874072
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13122.483     -13122.483     -13275.137     -13275.137      295.31917      295.31917      67974.826      67974.826     -14.142531     -14.142531    
     37000  -13127.898     -13127.898     -13280.284     -13280.284      294.80016      294.80016      67900.229      67900.229      319.03519      319.03519    
Loop time of 37.7484 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.486 hours/ns, 26.491 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    | 37.594     | 37.594     | 37.594     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02173    | 0.02173    | 0.02173    |   0.0 |  0.06
Output  | 5.0926e-05 | 5.0926e-05 | 5.0926e-05 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.32
Other   |            | 0.01112    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320706 ave      320706 max      320706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320706
Ave neighs/atom = 80.1765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.596959603099, Press = -0.223833847540623
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13127.898     -13127.898     -13280.284     -13280.284      294.80016      294.80016      67900.229      67900.229      319.03519      319.03519    
     38000  -13120.763     -13120.763     -13272.356     -13272.356      293.26534      293.26534      68010.664      68010.664     -98.46052      -98.46052     
Loop time of 37.8028 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.286 ns/day, 10.501 hours/ns, 26.453 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    | 37.648     | 37.648     | 37.648     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02176    | 0.02176    | 0.02176    |   0.0 |  0.06
Output  | 4.9854e-05 | 4.9854e-05 | 4.9854e-05 |   0.0 |  0.00
Modify  | 0.12203    | 0.12203    | 0.12203    |   0.0 |  0.32
Other   |            | 0.01111    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320610 ave      320610 max      320610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320610
Ave neighs/atom = 80.1525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.624436881918, Press = 0.415027693020483
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13120.763     -13120.763     -13272.356     -13272.356      293.26534      293.26534      68010.664      68010.664     -98.46052      -98.46052     
     39000  -13127.196     -13127.196     -13276.771     -13276.771      289.36352      289.36352      67913.946      67913.946      386.54257      386.54257    
Loop time of 37.8476 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.283 ns/day, 10.513 hours/ns, 26.422 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.693     | 37.693     | 37.693     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021869   | 0.021869   | 0.021869   |   0.0 |  0.06
Output  | 3.0047e-05 | 3.0047e-05 | 3.0047e-05 |   0.0 |  0.00
Modify  | 0.122      | 0.122      | 0.122      |   0.0 |  0.32
Other   |            | 0.01104    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320544 ave      320544 max      320544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320544
Ave neighs/atom = 80.136
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.703738688477, Press = -0.137655579685524
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13127.196     -13127.196     -13276.771     -13276.771      289.36352      289.36352      67913.946      67913.946      386.54257      386.54257    
     40000  -13123.774     -13123.774     -13275.097     -13275.097      292.74357      292.74357      68020.319      68020.319     -471.13362     -471.13362    
Loop time of 37.8207 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.284 ns/day, 10.506 hours/ns, 26.441 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.666     | 37.666     | 37.666     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021903   | 0.021903   | 0.021903   |   0.0 |  0.06
Output  | 5.1067e-05 | 5.1067e-05 | 5.1067e-05 |   0.0 |  0.00
Modify  | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.32
Other   |            | 0.01109    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320862 ave      320862 max      320862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320862
Ave neighs/atom = 80.2155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.738496496232, Press = 0.178339651547995
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13123.774     -13123.774     -13275.097     -13275.097      292.74357      292.74357      68020.319      68020.319     -471.13362     -471.13362    
     41000  -13128.715     -13128.715     -13280.955     -13280.955      294.51759      294.51759      67811.562      67811.562      1063.3719      1063.3719    
Loop time of 37.7602 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.288 ns/day, 10.489 hours/ns, 26.483 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.605     | 37.605     | 37.605     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021983   | 0.021983   | 0.021983   |   0.0 |  0.06
Output  | 4.6447e-05 | 4.6447e-05 | 4.6447e-05 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.32
Other   |            | 0.01103    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320498 ave      320498 max      320498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320498
Ave neighs/atom = 80.1245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765824828498, Press = 0.576548341529852
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13128.715     -13128.715     -13280.955     -13280.955      294.51759      294.51759      67811.562      67811.562      1063.3719      1063.3719    
     42000  -13123.058     -13123.058     -13274.54      -13274.54       293.05252      293.05252      68062.106      68062.106     -833.9037      -833.9037     
Loop time of 37.8254 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.284 ns/day, 10.507 hours/ns, 26.437 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.671     | 37.671     | 37.671     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021889   | 0.021889   | 0.021889   |   0.0 |  0.06
Output  | 3.0337e-05 | 3.0337e-05 | 3.0337e-05 |   0.0 |  0.00
Modify  | 0.12195    | 0.12195    | 0.12195    |   0.0 |  0.32
Other   |            | 0.01099    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       321020 ave      321020 max      321020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 321020
Ave neighs/atom = 80.255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.78210523705, Press = -0.838764506659607
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13123.058     -13123.058     -13274.54      -13274.54       293.05252      293.05252      68062.106      68062.106     -833.9037      -833.9037     
     43000  -13126.491     -13126.491     -13278.033     -13278.033      293.16847      293.16847      67920.529      67920.529      255.22753      255.22753    
Loop time of 37.7681 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.288 ns/day, 10.491 hours/ns, 26.477 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.613     | 37.613     | 37.613     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021849   | 0.021849   | 0.021849   |   0.0 |  0.06
Output  | 5.1668e-05 | 5.1668e-05 | 5.1668e-05 |   0.0 |  0.00
Modify  | 0.12194    | 0.12194    | 0.12194    |   0.0 |  0.32
Other   |            | 0.01106    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320370 ave      320370 max      320370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320370
Ave neighs/atom = 80.0925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755312293614, Press = 0.483783459830724
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13126.491     -13126.491     -13278.033     -13278.033      293.16847      293.16847      67920.529      67920.529      255.22753      255.22753    
     44000  -13128.669     -13128.669     -13277.366     -13277.366      287.66404      287.66404      67946.944      67946.944     -31.994272     -31.994272    
Loop time of 37.7628 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.288 ns/day, 10.490 hours/ns, 26.481 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.608     | 37.608     | 37.608     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021953   | 0.021953   | 0.021953   |   0.0 |  0.06
Output  | 3.0077e-05 | 3.0077e-05 | 3.0077e-05 |   0.0 |  0.00
Modify  | 0.12184    | 0.12184    | 0.12184    |   0.0 |  0.32
Other   |            | 0.01105    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320590 ave      320590 max      320590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320590
Ave neighs/atom = 80.1475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.759950139222, Press = -0.196133054072117
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13128.669     -13128.669     -13277.366     -13277.366      287.66404      287.66404      67946.944      67946.944     -31.994272     -31.994272    
     45000  -13123.856     -13123.856     -13277.861     -13277.861      297.93417      297.93417      67955.658      67955.658     -57.807846     -57.807846    
Loop time of 37.6919 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.292 ns/day, 10.470 hours/ns, 26.531 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.537     | 37.537     | 37.537     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021853   | 0.021853   | 0.021853   |   0.0 |  0.06
Output  | 6.877e-05  | 6.877e-05  | 6.877e-05  |   0.0 |  0.00
Modify  | 0.12208    | 0.12208    | 0.12208    |   0.0 |  0.32
Other   |            | 0.01105    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320612 ave      320612 max      320612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320612
Ave neighs/atom = 80.153
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.765180923384, Press = -0.289699478355367
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13123.856     -13123.856     -13277.861     -13277.861      297.93417      297.93417      67955.658      67955.658     -57.807846     -57.807846    
     46000  -13126.927     -13126.927     -13277.714     -13277.714      291.70802      291.70802      67968.504      67968.504     -254.25193     -254.25193    
Loop time of 37.7059 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.474 hours/ns, 26.521 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.551     | 37.551     | 37.551     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021899   | 0.021899   | 0.021899   |   0.0 |  0.06
Output  | 5.1327e-05 | 5.1327e-05 | 5.1327e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.32
Other   |            | 0.01105    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320600 ave      320600 max      320600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320600
Ave neighs/atom = 80.15
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.798327104928, Press = 0.161847819752229
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13126.927     -13126.927     -13277.714     -13277.714      291.70802      291.70802      67968.504      67968.504     -254.25193     -254.25193    
     47000  -13125.084     -13125.084     -13278.878     -13278.878      297.52544      297.52544      67941.9        67941.9       -15.747372     -15.747372    
Loop time of 37.7126 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.291 ns/day, 10.476 hours/ns, 26.516 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.558     | 37.558     | 37.558     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021875   | 0.021875   | 0.021875   |   0.0 |  0.06
Output  | 3.0157e-05 | 3.0157e-05 | 3.0157e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.32
Other   |            | 0.01111    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320706 ave      320706 max      320706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320706
Ave neighs/atom = 80.1765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824359467235, Press = 0.0914396135391236
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13125.084     -13125.084     -13278.878     -13278.878      297.52544      297.52544      67941.9        67941.9       -15.747372     -15.747372    
     48000  -13124.653     -13124.653     -13277.9       -13277.9        296.46768      296.46768      67983.169      67983.169     -331.49686     -331.49686    
Loop time of 37.7243 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.290 ns/day, 10.479 hours/ns, 26.508 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.569     | 37.569     | 37.569     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021892   | 0.021892   | 0.021892   |   0.0 |  0.06
Output  | 5.1096e-05 | 5.1096e-05 | 5.1096e-05 |   0.0 |  0.00
Modify  | 0.12184    | 0.12184    | 0.12184    |   0.0 |  0.32
Other   |            | 0.01107    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320602 ave      320602 max      320602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320602
Ave neighs/atom = 80.1505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828421907038, Press = -0.264837292003107
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13124.653     -13124.653     -13277.9       -13277.9        296.46768      296.46768      67983.169      67983.169     -331.49686     -331.49686    
     49000  -13124.881     -13124.881     -13276.583     -13276.583      293.4779       293.4779       67949.855      67949.855      85.324055      85.324055    
Loop time of 37.7486 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.289 ns/day, 10.486 hours/ns, 26.491 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.594     | 37.594     | 37.594     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021919   | 0.021919   | 0.021919   |   0.0 |  0.06
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.32
Other   |            | 0.01126    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320524 ave      320524 max      320524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320524
Ave neighs/atom = 80.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88839755165, Press = 0.0339150560708308
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13124.881     -13124.881     -13276.583     -13276.583      293.4779       293.4779       67949.855      67949.855      85.324055      85.324055    
     50000  -13123.13      -13123.13      -13274.656     -13274.656      293.13726      293.13726      67955.697      67955.697      256.55586      256.55586    
Loop time of 37.7031 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.292 ns/day, 10.473 hours/ns, 26.523 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.548     | 37.548     | 37.548     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021839   | 0.021839   | 0.021839   |   0.0 |  0.06
Output  | 3.0357e-05 | 3.0357e-05 | 3.0357e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.32
Other   |            | 0.01109    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320586 ave      320586 max      320586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320586
Ave neighs/atom = 80.1465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896835652478, Press = -0.271328587992864
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13123.13      -13123.13      -13274.656     -13274.656      293.13726      293.13726      67955.697      67955.697      256.55586      256.55586    
     51000  -13127.092     -13127.092     -13276.464     -13276.464      288.97091      288.97091      67989.736      67989.736     -356.46495     -356.46495    
Loop time of 37.6882 on 1 procs for 1000 steps with 4000 atoms

Performance: 2.292 ns/day, 10.469 hours/ns, 26.533 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.534     | 37.534     | 37.534     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021903   | 0.021903   | 0.021903   |   0.0 |  0.06
Output  | 5.0606e-05 | 5.0606e-05 | 5.0606e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.32
Other   |            | 0.01107    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320558 ave      320558 max      320558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 320558
Ave neighs/atom = 80.1395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.938461118125, Press = -0.021467747551632
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 = 12 12 12
  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) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13127.092     -13127.092     -13276.464     -13276.464      288.97091      288.97091      67989.736      67989.736     -356.46495     -356.46495    
     52000  -13122.221     -13122.221     -13275.668     -13275.668      296.85293      296.85293      67902.325      67902.325      688.90956      688.90956    
Loop time of 37.6904 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 37.536     | 37.536     | 37.536     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021906   | 0.021906   | 0.021906   |   0.0 |  0.06
Output  | 7.2407e-05 | 7.2407e-05 | 7.2407e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.32
Other   |            | 0.01101    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 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:       320526 ave      320526 max      320526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0