# 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 2.850243076682091*${_u_distance}
variable latticeconst_converted equal 2.850243076682091*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85024307668209
Lattice spacing in x,y,z = 2.8502431 2.8502431 2.8502431
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.502431 28.502431 28.502431)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (28.502431 28.502431 28.502431)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_MahataMukhopadhyayAsleZaeem_2022_AlFe__MO_304347095149_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 313.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "313.15 - 0.2"
variable      T_up  equal  "313.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_304347095149_001#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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8499.7626     -8499.7626     -8580.6777     -8580.6777      313.15         313.15         23155.049      23155.049      3732.5262      3732.5262    
      1000  -8415.5519     -8415.5519     -8496.4054     -8496.4054      312.91137      312.91137      23387.703      23387.703      227.59439      227.59439    
Loop time of 36.3784 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.375 ns/day, 10.105 hours/ns, 27.489 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    | 36.297     | 36.297     | 36.297     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015173   | 0.015173   | 0.015173   |   0.0 |  0.04
Output  | 0.00010788 | 0.00010788 | 0.00010788 |   0.0 |  0.00
Modify  | 0.060131   | 0.060131   | 0.060131   |   0.0 |  0.17
Other   |            | 0.005545   |            |       |  0.02

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

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

Performance: 2.087 ns/day, 11.501 hours/ns, 24.153 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    | 41.323     | 41.323     | 41.323     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.04
Output  | 4.9763e-05 | 4.9763e-05 | 4.9763e-05 |   0.0 |  0.00
Modify  | 0.059686   | 0.059686   | 0.059686   |   0.0 |  0.14
Other   |            | 0.005386   |            |       |  0.01

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

Total # of neighbors = 132610
Ave neighs/atom = 66.305
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8415.3266     -8415.3266     -8494.5896     -8494.5896      306.7557       306.7557       23419.683      23419.683     -1830.8253     -1830.8253    
      3000  -8416.6119     -8416.6119     -8500.4611     -8500.4611      324.50472      324.50472      23374.918      23374.918      688.39578      688.39578    
Loop time of 41.5361 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.080 ns/day, 11.538 hours/ns, 24.075 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    | 41.456     | 41.456     | 41.456     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014915   | 0.014915   | 0.014915   |   0.0 |  0.04
Output  | 4.5996e-05 | 4.5996e-05 | 4.5996e-05 |   0.0 |  0.00
Modify  | 0.05983    | 0.05983    | 0.05983    |   0.0 |  0.14
Other   |            | 0.005278   |            |       |  0.01

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

Total # of neighbors = 132288
Ave neighs/atom = 66.144
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8416.6119     -8416.6119     -8500.4611     -8500.4611      324.50472      324.50472      23374.918      23374.918      688.39578      688.39578    
      4000  -8414.7524     -8414.7524     -8495.702      -8495.702       313.28353      313.28353      23386.54       23386.54       538.76807      538.76807    
Loop time of 41.7119 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.071 ns/day, 11.587 hours/ns, 23.974 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    | 41.632     | 41.632     | 41.632     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.04
Output  | 4.7179e-05 | 4.7179e-05 | 4.7179e-05 |   0.0 |  0.00
Modify  | 0.05965    | 0.05965    | 0.05965    |   0.0 |  0.14
Other   |            | 0.005236   |            |       |  0.01

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

Total # of neighbors = 131692
Ave neighs/atom = 65.846
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8414.7524     -8414.7524     -8495.702      -8495.702       313.28353      313.28353      23386.54       23386.54       538.76807      538.76807    
      5000  -8417.353      -8417.353      -8498.3992     -8498.3992      313.65728      313.65728      23418.079      23418.079     -2029.098      -2029.098     
Loop time of 41.6337 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.075 ns/day, 11.565 hours/ns, 24.019 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 41.553     | 41.553     | 41.553     |   0.0 | 99.81
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015073   | 0.015073   | 0.015073   |   0.0 |  0.04
Output  | 2.8734e-05 | 2.8734e-05 | 2.8734e-05 |   0.0 |  0.00
Modify  | 0.060014   | 0.060014   | 0.060014   |   0.0 |  0.14
Other   |            | 0.005222   |            |       |  0.01

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

Total # of neighbors = 132190
Ave neighs/atom = 66.095
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 = 310.58497002385, Press = -301.499217261209
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8417.353      -8417.353      -8498.3992     -8498.3992      313.65728      313.65728      23418.079      23418.079     -2029.098      -2029.098     
      6000  -8415.7195     -8415.7195     -8493.5207     -8493.5207      301.09844      301.09844      23410.547      23410.547     -952.11011     -952.11011    
Loop time of 41.6359 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.075 ns/day, 11.566 hours/ns, 24.018 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    | 41.554     | 41.554     | 41.554     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015044   | 0.015044   | 0.015044   |   0.0 |  0.04
Output  | 3.8923e-05 | 3.8923e-05 | 3.8923e-05 |   0.0 |  0.00
Modify  | 0.061916   | 0.061916   | 0.061916   |   0.0 |  0.15
Other   |            | 0.005319   |            |       |  0.01

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

Total # of neighbors = 131828
Ave neighs/atom = 65.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.152151164173, Press = 80.459584750637
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8415.7195     -8415.7195     -8493.5207     -8493.5207      301.09844      301.09844      23410.547      23410.547     -952.11011     -952.11011    
      7000  -8415.3275     -8415.3275     -8495.3721     -8495.3721      309.78074      309.78074      23347.69       23347.69       3385.339       3385.339     
Loop time of 41.7778 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.605 hours/ns, 23.936 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    | 41.696     | 41.696     | 41.696     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014875   | 0.014875   | 0.014875   |   0.0 |  0.04
Output  | 3.7079e-05 | 3.7079e-05 | 3.7079e-05 |   0.0 |  0.00
Modify  | 0.061966   | 0.061966   | 0.061966   |   0.0 |  0.15
Other   |            | 0.005355   |            |       |  0.01

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

Total # of neighbors = 132232
Ave neighs/atom = 66.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.236676064291, Press = 16.9090489237042
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8415.3275     -8415.3275     -8495.3721     -8495.3721      309.78074      309.78074      23347.69       23347.69       3385.339       3385.339     
      8000  -8412.8752     -8412.8752     -8496.157      -8496.157       322.30925      322.30925      23391.632      23391.632      231.0717       231.0717     
Loop time of 41.7245 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.071 ns/day, 11.590 hours/ns, 23.967 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    | 41.642     | 41.642     | 41.642     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014953   | 0.014953   | 0.014953   |   0.0 |  0.04
Output  | 3.5316e-05 | 3.5316e-05 | 3.5316e-05 |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.15
Other   |            | 0.005266   |            |       |  0.01

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

Total # of neighbors = 132298
Ave neighs/atom = 66.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.821286590592, Press = -14.1271889810826
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8412.8752     -8412.8752     -8496.157      -8496.157       322.30925      322.30925      23391.632      23391.632      231.0717       231.0717     
      9000  -8416.988      -8416.988      -8496.7735     -8496.7735      308.77795      308.77795      23394.682      23394.682     -285.56431     -285.56431    
Loop time of 41.6478 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.075 ns/day, 11.569 hours/ns, 24.011 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    | 41.565     | 41.565     | 41.565     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.04
Output  | 2.8483e-05 | 2.8483e-05 | 2.8483e-05 |   0.0 |  0.00
Modify  | 0.06211    | 0.06211    | 0.06211    |   0.0 |  0.15
Other   |            | 0.005249   |            |       |  0.01

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

Total # of neighbors = 132232
Ave neighs/atom = 66.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.887560023466, Press = 0.465880394669149
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8416.988      -8416.988      -8496.7735     -8496.7735      308.77795      308.77795      23394.682      23394.682     -285.56431     -285.56431    
     10000  -8415.1128     -8415.1128     -8497.5496     -8497.5496      319.03884      319.03884      23388.876      23388.876      180.16103      180.16103    
Loop time of 41.7291 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.070 ns/day, 11.591 hours/ns, 23.964 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    | 41.647     | 41.647     | 41.647     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01504    | 0.01504    | 0.01504    |   0.0 |  0.04
Output  | 3.6739e-05 | 3.6739e-05 | 3.6739e-05 |   0.0 |  0.00
Modify  | 0.062075   | 0.062075   | 0.062075   |   0.0 |  0.15
Other   |            | 0.005307   |            |       |  0.01

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

Total # of neighbors = 132126
Ave neighs/atom = 66.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.421472557299, Press = 5.42806821117302
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8415.1128     -8415.1128     -8497.5496     -8497.5496      319.03884      319.03884      23388.876      23388.876      180.16103      180.16103    
     11000  -8417.8077     -8417.8077     -8496.6767     -8496.6767      305.23109      305.23109      23366.459      23366.459      1685.5262      1685.5262    
Loop time of 41.6551 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.074 ns/day, 11.571 hours/ns, 24.007 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    | 41.573     | 41.573     | 41.573     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014988   | 0.014988   | 0.014988   |   0.0 |  0.04
Output  | 3.6589e-05 | 3.6589e-05 | 3.6589e-05 |   0.0 |  0.00
Modify  | 0.061896   | 0.061896   | 0.061896   |   0.0 |  0.15
Other   |            | 0.005296   |            |       |  0.01

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

Total # of neighbors = 132186
Ave neighs/atom = 66.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.272156189181, Press = -5.35583666469735
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8417.8077     -8417.8077     -8496.6767     -8496.6767      305.23109      305.23109      23366.459      23366.459      1685.5262      1685.5262    
     12000  -8417.5143     -8417.5143     -8498.2844     -8498.2844      312.58853      312.58853      23415.622      23415.622     -1806.4468     -1806.4468    
Loop time of 41.7365 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.070 ns/day, 11.593 hours/ns, 23.960 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    | 41.654     | 41.654     | 41.654     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.04
Output  | 2.8293e-05 | 2.8293e-05 | 2.8293e-05 |   0.0 |  0.00
Modify  | 0.061868   | 0.061868   | 0.061868   |   0.0 |  0.15
Other   |            | 0.005273   |            |       |  0.01

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

Total # of neighbors = 132292
Ave neighs/atom = 66.146
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.840344988575, Press = -9.37917981641747
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8417.5143     -8417.5143     -8498.2844     -8498.2844      312.58853      312.58853      23415.622      23415.622     -1806.4468     -1806.4468    
     13000  -8415.7797     -8415.7797     -8495.6498     -8495.6498      309.10579      309.10579      23423.025      23423.025     -2164.792      -2164.792     
Loop time of 41.8148 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.066 ns/day, 11.615 hours/ns, 23.915 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    | 41.733     | 41.733     | 41.733     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014963   | 0.014963   | 0.014963   |   0.0 |  0.04
Output  | 3.7761e-05 | 3.7761e-05 | 3.7761e-05 |   0.0 |  0.00
Modify  | 0.061948   | 0.061948   | 0.061948   |   0.0 |  0.15
Other   |            | 0.005283   |            |       |  0.01

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

Total # of neighbors = 131712
Ave neighs/atom = 65.856
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.729546835596, Press = 4.99072965944421
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8415.7797     -8415.7797     -8495.6498     -8495.6498      309.10579      309.10579      23423.025      23423.025     -2164.792      -2164.792     
     14000  -8415.4876     -8415.4876     -8496.3767     -8496.3767      313.04929      313.04929      23382.573      23382.573      640.99118      640.99118    
Loop time of 41.8909 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.062 ns/day, 11.636 hours/ns, 23.872 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    | 41.809     | 41.809     | 41.809     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014998   | 0.014998   | 0.014998   |   0.0 |  0.04
Output  | 3.6559e-05 | 3.6559e-05 | 3.6559e-05 |   0.0 |  0.00
Modify  | 0.062028   | 0.062028   | 0.062028   |   0.0 |  0.15
Other   |            | 0.005325   |            |       |  0.01

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

Total # of neighbors = 132086
Ave neighs/atom = 66.043
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.744898975855, Press = 6.51245664977362
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8415.4876     -8415.4876     -8496.3767     -8496.3767      313.04929      313.04929      23382.573      23382.573      640.99118      640.99118    
     15000  -8414.2883     -8414.2883     -8495.2056     -8495.2056      313.15828      313.15828      23362.194      23362.194      2385.8513      2385.8513    
Loop time of 41.6739 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.073 ns/day, 11.576 hours/ns, 23.996 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    | 41.592     | 41.592     | 41.592     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014886   | 0.014886   | 0.014886   |   0.0 |  0.04
Output  | 2.8433e-05 | 2.8433e-05 | 2.8433e-05 |   0.0 |  0.00
Modify  | 0.061886   | 0.061886   | 0.061886   |   0.0 |  0.15
Other   |            | 0.005257   |            |       |  0.01

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

Total # of neighbors = 132000
Ave neighs/atom = 66
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.102907049523, Press = -0.628149785894486
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8414.2883     -8414.2883     -8495.2056     -8495.2056      313.15828      313.15828      23362.194      23362.194      2385.8513      2385.8513    
     16000  -8414.7706     -8414.7706     -8495.4321     -8495.4321      312.16812      312.16812      23386.49       23386.49       613.6387       613.6387     
Loop time of 41.8975 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.062 ns/day, 11.638 hours/ns, 23.868 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    | 41.815     | 41.815     | 41.815     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.04
Output  | 3.6298e-05 | 3.6298e-05 | 3.6298e-05 |   0.0 |  0.00
Modify  | 0.062154   | 0.062154   | 0.062154   |   0.0 |  0.15
Other   |            | 0.005305   |            |       |  0.01

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

Total # of neighbors = 132330
Ave neighs/atom = 66.165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.120514127482, Press = -6.8311177298755
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8414.7706     -8414.7706     -8495.4321     -8495.4321      312.16812      312.16812      23386.49       23386.49       613.6387       613.6387     
     17000  -8417.9775     -8417.9775     -8497.4627     -8497.4627      307.61561      307.61561      23422.525      23422.525     -2383.7861     -2383.7861    
Loop time of 41.7531 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.069 ns/day, 11.598 hours/ns, 23.950 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    | 41.671     | 41.671     | 41.671     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.04
Output  | 3.6749e-05 | 3.6749e-05 | 3.6749e-05 |   0.0 |  0.00
Modify  | 0.061941   | 0.061941   | 0.061941   |   0.0 |  0.15
Other   |            | 0.005276   |            |       |  0.01

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

Total # of neighbors = 132104
Ave neighs/atom = 66.052
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.091031158961, Press = -3.69822449134993
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8417.9775     -8417.9775     -8497.4627     -8497.4627      307.61561      307.61561      23422.525      23422.525     -2383.7861     -2383.7861    
     18000  -8410.356      -8410.356      -8492.3738     -8492.3738      317.41756      317.41756      23403.379      23403.379     -155.99323     -155.99323    
Loop time of 41.6887 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.073 ns/day, 11.580 hours/ns, 23.987 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    | 41.606     | 41.606     | 41.606     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014999   | 0.014999   | 0.014999   |   0.0 |  0.04
Output  | 2.7842e-05 | 2.7842e-05 | 2.7842e-05 |   0.0 |  0.00
Modify  | 0.062006   | 0.062006   | 0.062006   |   0.0 |  0.15
Other   |            | 0.00528    |            |       |  0.01

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

Total # of neighbors = 131898
Ave neighs/atom = 65.949
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.261112038744, Press = 1.00563330436227
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8410.356      -8410.356      -8492.3738     -8492.3738      317.41756      317.41756      23403.379      23403.379     -155.99323     -155.99323    
     19000  -8417.3087     -8417.3087     -8497.5787     -8497.5787      310.65326      310.65326      23388.53       23388.53       0.7346907      0.7346907    
Loop time of 41.7722 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.603 hours/ns, 23.939 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    | 41.69      | 41.69      | 41.69      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.04
Output  | 3.6638e-05 | 3.6638e-05 | 3.6638e-05 |   0.0 |  0.00
Modify  | 0.062068   | 0.062068   | 0.062068   |   0.0 |  0.15
Other   |            | 0.005273   |            |       |  0.01

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

Total # of neighbors = 132280
Ave neighs/atom = 66.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.324198045519, Press = 0.689195845443073
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8417.3087     -8417.3087     -8497.5787     -8497.5787      310.65326      310.65326      23388.53       23388.53       0.7346907      0.7346907    
     20000  -8413.8666     -8413.8666     -8495.4971     -8495.4971      315.91865      315.91865      23388.362      23388.362      438.66487      438.66487    
Loop time of 41.6275 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.076 ns/day, 11.563 hours/ns, 24.023 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    | 41.545     | 41.545     | 41.545     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.04
Output  | 3.5557e-05 | 3.5557e-05 | 3.5557e-05 |   0.0 |  0.00
Modify  | 0.061891   | 0.061891   | 0.061891   |   0.0 |  0.15
Other   |            | 0.005263   |            |       |  0.01

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

Total # of neighbors = 132148
Ave neighs/atom = 66.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45872224428, Press = 0.276199029329859
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8413.8666     -8413.8666     -8495.4971     -8495.4971      315.91865      315.91865      23388.362      23388.362      438.66487      438.66487    
     21000  -8414.9243     -8414.9243     -8495.4373     -8495.4373      311.59364      311.59364      23379.378      23379.378      1098.2453      1098.2453    
Loop time of 41.6912 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.072 ns/day, 11.581 hours/ns, 23.986 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    | 41.609     | 41.609     | 41.609     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015138   | 0.015138   | 0.015138   |   0.0 |  0.04
Output  | 3.754e-05  | 3.754e-05  | 3.754e-05  |   0.0 |  0.00
Modify  | 0.06204    | 0.06204    | 0.06204    |   0.0 |  0.15
Other   |            | 0.005269   |            |       |  0.01

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

Total # of neighbors = 132222
Ave neighs/atom = 66.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397774815034, Press = -0.776073700624637
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8414.9243     -8414.9243     -8495.4373     -8495.4373      311.59364      311.59364      23379.378      23379.378      1098.2453      1098.2453    
     22000  -8417.0035     -8417.0035     -8498.8077     -8498.8077      316.59079      316.59079      23411.064      23411.064     -1644.5089     -1644.5089    
Loop time of 41.8078 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.067 ns/day, 11.613 hours/ns, 23.919 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    | 41.725     | 41.725     | 41.725     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015025   | 0.015025   | 0.015025   |   0.0 |  0.04
Output  | 2.8534e-05 | 2.8534e-05 | 2.8534e-05 |   0.0 |  0.00
Modify  | 0.06223    | 0.06223    | 0.06223    |   0.0 |  0.15
Other   |            | 0.005306   |            |       |  0.01

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

Total # of neighbors = 132242
Ave neighs/atom = 66.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.415129000272, Press = -3.48447852097503
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8417.0035     -8417.0035     -8498.8077     -8498.8077      316.59079      316.59079      23411.064      23411.064     -1644.5089     -1644.5089    
     23000  -8418.5519     -8418.5519     -8497.4234     -8497.4234      305.24084      305.24084      23411.619      23411.619     -1641.3398     -1641.3398    
Loop time of 41.8804 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.063 ns/day, 11.633 hours/ns, 23.878 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    | 41.798     | 41.798     | 41.798     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.04
Output  | 3.8111e-05 | 3.8111e-05 | 3.8111e-05 |   0.0 |  0.00
Modify  | 0.062062   | 0.062062   | 0.062062   |   0.0 |  0.15
Other   |            | 0.005311   |            |       |  0.01

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

Total # of neighbors = 131930
Ave neighs/atom = 65.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.202088544328, Press = 1.88618592742163
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8418.5519     -8418.5519     -8497.4234     -8497.4234      305.24084      305.24084      23411.619      23411.619     -1641.3398     -1641.3398    
     24000  -8415.2952     -8415.2952     -8498.2048     -8498.2048      320.86851      320.86851      23368.75       23368.75       1422.6112      1422.6112    
Loop time of 41.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.072 ns/day, 11.585 hours/ns, 23.977 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    | 41.624     | 41.624     | 41.624     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01501    | 0.01501    | 0.01501    |   0.0 |  0.04
Output  | 3.5707e-05 | 3.5707e-05 | 3.5707e-05 |   0.0 |  0.00
Modify  | 0.061851   | 0.061851   | 0.061851   |   0.0 |  0.15
Other   |            | 0.005293   |            |       |  0.01

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

Total # of neighbors = 131820
Ave neighs/atom = 65.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.171271038114, Press = 2.44320434530155
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8415.2952     -8415.2952     -8498.2048     -8498.2048      320.86851      320.86851      23368.75       23368.75       1422.6112      1422.6112    
     25000  -8417.8448     -8417.8448     -8499.4562     -8499.4562      315.8445       315.8445       23344.363      23344.363      2864.4729      2864.4729    
Loop time of 41.7712 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.603 hours/ns, 23.940 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    | 41.689     | 41.689     | 41.689     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015003   | 0.015003   | 0.015003   |   0.0 |  0.04
Output  | 2.8493e-05 | 2.8493e-05 | 2.8493e-05 |   0.0 |  0.00
Modify  | 0.062036   | 0.062036   | 0.062036   |   0.0 |  0.15
Other   |            | 0.005243   |            |       |  0.01

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

Total # of neighbors = 132150
Ave neighs/atom = 66.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.024824354911, Press = -2.4169627158535
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8417.8448     -8417.8448     -8499.4562     -8499.4562      315.8445       315.8445       23344.363      23344.363      2864.4729      2864.4729    
     26000  -8417.9369     -8417.9369     -8498.4867     -8498.4867      311.73625      311.73625      23424.203      23424.203     -2629.9551     -2629.9551    
Loop time of 41.7428 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.070 ns/day, 11.595 hours/ns, 23.956 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    | 41.66      | 41.66      | 41.66      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015019   | 0.015019   | 0.015019   |   0.0 |  0.04
Output  | 3.6248e-05 | 3.6248e-05 | 3.6248e-05 |   0.0 |  0.00
Modify  | 0.061958   | 0.061958   | 0.061958   |   0.0 |  0.15
Other   |            | 0.005296   |            |       |  0.01

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

Total # of neighbors = 132176
Ave neighs/atom = 66.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.0212051066, Press = -6.56212887166833
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8417.9369     -8417.9369     -8498.4867     -8498.4867      311.73625      311.73625      23424.203      23424.203     -2629.9551     -2629.9551    
     27000  -8412.942      -8412.942      -8495.1302     -8495.1302      318.07686      318.07686      23425.071      23425.071     -2011.1169     -2011.1169    
Loop time of 41.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.073 ns/day, 11.577 hours/ns, 23.995 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    | 41.594     | 41.594     | 41.594     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015045   | 0.015045   | 0.015045   |   0.0 |  0.04
Output  | 3.6699e-05 | 3.6699e-05 | 3.6699e-05 |   0.0 |  0.00
Modify  | 0.061913   | 0.061913   | 0.061913   |   0.0 |  0.15
Other   |            | 0.005291   |            |       |  0.01

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

Total # of neighbors = 131918
Ave neighs/atom = 65.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.014863500122, Press = 0.645297605374108
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8412.942      -8412.942      -8495.1302     -8495.1302      318.07686      318.07686      23425.071      23425.071     -2011.1169     -2011.1169    
     28000  -8416.6575     -8416.6575     -8497.7752     -8497.7752      313.93396      313.93396      23388.951      23388.951     -47.196698     -47.196698    
Loop time of 41.8552 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.064 ns/day, 11.626 hours/ns, 23.892 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    | 41.773     | 41.773     | 41.773     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015073   | 0.015073   | 0.015073   |   0.0 |  0.04
Output  | 2.8313e-05 | 2.8313e-05 | 2.8313e-05 |   0.0 |  0.00
Modify  | 0.062141   | 0.062141   | 0.062141   |   0.0 |  0.15
Other   |            | 0.005287   |            |       |  0.01

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

Total # of neighbors = 132128
Ave neighs/atom = 66.064
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.042429026064, Press = 1.38107933379086
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8416.6575     -8416.6575     -8497.7752     -8497.7752      313.93396      313.93396      23388.951      23388.951     -47.196698     -47.196698    
     29000  -8415.8228     -8415.8228     -8496.4264     -8496.4264      311.94426      311.94426      23372.02       23372.02       1418.7646      1418.7646    
Loop time of 41.9296 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.061 ns/day, 11.647 hours/ns, 23.850 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    | 41.847     | 41.847     | 41.847     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.04
Output  | 3.686e-05  | 3.686e-05  | 3.686e-05  |   0.0 |  0.00
Modify  | 0.062062   | 0.062062   | 0.062062   |   0.0 |  0.15
Other   |            | 0.005271   |            |       |  0.01

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

Total # of neighbors = 131940
Ave neighs/atom = 65.97
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.954020025601, Press = 0.305943204338849
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8415.8228     -8415.8228     -8496.4264     -8496.4264      311.94426      311.94426      23372.02       23372.02       1418.7646      1418.7646    
     30000  -8420.0741     -8420.0741     -8497.8539     -8497.8539      301.01615      301.01615      23383.906      23383.906      250.70467      250.70467    
Loop time of 41.9561 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.059 ns/day, 11.654 hours/ns, 23.834 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    | 41.874     | 41.874     | 41.874     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014972   | 0.014972   | 0.014972   |   0.0 |  0.04
Output  | 3.6419e-05 | 3.6419e-05 | 3.6419e-05 |   0.0 |  0.00
Modify  | 0.062069   | 0.062069   | 0.062069   |   0.0 |  0.15
Other   |            | 0.005275   |            |       |  0.01

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

Total # of neighbors = 132314
Ave neighs/atom = 66.157
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.919852137013, Press = -3.24827220178196
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8420.0741     -8420.0741     -8497.8539     -8497.8539      301.01615      301.01615      23383.906      23383.906      250.70467      250.70467    
     31000  -8415.2085     -8415.2085     -8495.368      -8495.368       310.2258       310.2258       23454.005      23454.005     -4137.4897     -4137.4897    
Loop time of 41.8956 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.062 ns/day, 11.638 hours/ns, 23.869 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    | 41.813     | 41.813     | 41.813     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015043   | 0.015043   | 0.015043   |   0.0 |  0.04
Output  | 3.3323e-05 | 3.3323e-05 | 3.3323e-05 |   0.0 |  0.00
Modify  | 0.062024   | 0.062024   | 0.062024   |   0.0 |  0.15
Other   |            | 0.005281   |            |       |  0.01

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

Total # of neighbors = 132024
Ave neighs/atom = 66.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.84237592298, Press = -0.898644591342553
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8415.2085     -8415.2085     -8495.368      -8495.368       310.2258       310.2258       23454.005      23454.005     -4137.4897     -4137.4897    
     32000  -8417.538      -8417.538      -8497.1455     -8497.1455      308.08902      308.08902      23390.398      23390.398     -89.719793     -89.719793    
Loop time of 41.8186 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.066 ns/day, 11.616 hours/ns, 23.913 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    | 41.736     | 41.736     | 41.736     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014931   | 0.014931   | 0.014931   |   0.0 |  0.04
Output  | 2.8443e-05 | 2.8443e-05 | 2.8443e-05 |   0.0 |  0.00
Modify  | 0.061913   | 0.061913   | 0.061913   |   0.0 |  0.15
Other   |            | 0.005281   |            |       |  0.01

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

Total # of neighbors = 131820
Ave neighs/atom = 65.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.814904853858, Press = 3.34096060559756
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8417.538      -8417.538      -8497.1455     -8497.1455      308.08902      308.08902      23390.398      23390.398     -89.719793     -89.719793    
     33000  -8415.3842     -8415.3842     -8495.337      -8495.337       309.42555      309.42555      23356.409      23356.409      2606.8183      2606.8183    
Loop time of 41.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.064 ns/day, 11.630 hours/ns, 23.885 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    | 41.785     | 41.785     | 41.785     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014984   | 0.014984   | 0.014984   |   0.0 |  0.04
Output  | 3.6689e-05 | 3.6689e-05 | 3.6689e-05 |   0.0 |  0.00
Modify  | 0.06207    | 0.06207    | 0.06207    |   0.0 |  0.15
Other   |            | 0.005293   |            |       |  0.01

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

Total # of neighbors = 132068
Ave neighs/atom = 66.034
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.876078174318, Press = 0.246842495251859
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8415.3842     -8415.3842     -8495.337      -8495.337       309.42555      309.42555      23356.409      23356.409      2606.8183      2606.8183    
     34000  -8413.638      -8413.638      -8495.6852     -8495.6852      317.53086      317.53086      23383.554      23383.554      756.95754      756.95754    
Loop time of 42.0282 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.056 ns/day, 11.675 hours/ns, 23.794 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    | 41.946     | 41.946     | 41.946     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015096   | 0.015096   | 0.015096   |   0.0 |  0.04
Output  | 3.739e-05  | 3.739e-05  | 3.739e-05  |   0.0 |  0.00
Modify  | 0.061956   | 0.061956   | 0.061956   |   0.0 |  0.15
Other   |            | 0.005322   |            |       |  0.01

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

Total # of neighbors = 132368
Ave neighs/atom = 66.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 = 312.892221088121, Press = -1.47689347431255
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8413.638      -8413.638      -8495.6852     -8495.6852      317.53086      317.53086      23383.554      23383.554      756.95754      756.95754    
     35000  -8417.2242     -8417.2242     -8497.247      -8497.247       309.69646      309.69646      23411.42       23411.42      -1569.0097     -1569.0097    
Loop time of 41.8253 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.066 ns/day, 11.618 hours/ns, 23.909 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    | 41.743     | 41.743     | 41.743     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015004   | 0.015004   | 0.015004   |   0.0 |  0.04
Output  | 2.8684e-05 | 2.8684e-05 | 2.8684e-05 |   0.0 |  0.00
Modify  | 0.061941   | 0.061941   | 0.061941   |   0.0 |  0.15
Other   |            | 0.005305   |            |       |  0.01

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

Total # of neighbors = 132282
Ave neighs/atom = 66.141
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.003507096573, Press = -0.98530362902352
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8417.2242     -8417.2242     -8497.247      -8497.247       309.69646      309.69646      23411.42       23411.42      -1569.0097     -1569.0097    
     36000  -8412.9253     -8412.9253     -8496.7283     -8496.7283      324.32613      324.32613      23436.833      23436.833     -2981.9177     -2981.9177    
Loop time of 41.7683 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.069 ns/day, 11.602 hours/ns, 23.942 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    | 41.686     | 41.686     | 41.686     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.04
Output  | 4.4664e-05 | 4.4664e-05 | 4.4664e-05 |   0.0 |  0.00
Modify  | 0.062147   | 0.062147   | 0.062147   |   0.0 |  0.15
Other   |            | 0.00542    |            |       |  0.01

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

Total # of neighbors = 131894
Ave neighs/atom = 65.947
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.040562658649, Press = 1.81344160591478
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8412.9253     -8412.9253     -8496.7283     -8496.7283      324.32613      324.32613      23436.833      23436.833     -2981.9177     -2981.9177    
     37000  -8416.2887     -8416.2887     -8496.4774     -8496.4774      310.33827      310.33827      23349.707      23349.707      2977.5586      2977.5586    
Loop time of 41.7714 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.603 hours/ns, 23.940 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    | 41.689     | 41.689     | 41.689     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014968   | 0.014968   | 0.014968   |   0.0 |  0.04
Output  | 3.9314e-05 | 3.9314e-05 | 3.9314e-05 |   0.0 |  0.00
Modify  | 0.062187   | 0.062187   | 0.062187   |   0.0 |  0.15
Other   |            | 0.005466   |            |       |  0.01

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

Total # of neighbors = 131646
Ave neighs/atom = 65.823
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.050870202648, Press = 3.55723691146976
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8416.2887     -8416.2887     -8496.4774     -8496.4774      310.33827      310.33827      23349.707      23349.707      2977.5586      2977.5586    
     38000  -8414.9148     -8414.9148     -8498.7523     -8498.7523      324.45991      324.45991      23361.858      23361.858      1872.921       1872.921     
Loop time of 41.7159 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.071 ns/day, 11.588 hours/ns, 23.972 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    | 41.633     | 41.633     | 41.633     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014954   | 0.014954   | 0.014954   |   0.0 |  0.04
Output  | 9.6271e-05 | 9.6271e-05 | 9.6271e-05 |   0.0 |  0.00
Modify  | 0.062165   | 0.062165   | 0.062165   |   0.0 |  0.15
Other   |            | 0.005447   |            |       |  0.01

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

Total # of neighbors = 132402
Ave neighs/atom = 66.201
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.087837024715, Press = -0.872812548379642
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8414.9148     -8414.9148     -8498.7523     -8498.7523      324.45991      324.45991      23361.858      23361.858      1872.921       1872.921     
     39000  -8416.475      -8416.475      -8496.6996     -8496.6996      310.47734      310.47734      23401.235      23401.235     -613.03055     -613.03055    
Loop time of 41.7253 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.071 ns/day, 11.590 hours/ns, 23.966 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    | 41.642     | 41.642     | 41.642     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015028   | 0.015028   | 0.015028   |   0.0 |  0.04
Output  | 3.8613e-05 | 3.8613e-05 | 3.8613e-05 |   0.0 |  0.00
Modify  | 0.062434   | 0.062434   | 0.062434   |   0.0 |  0.15
Other   |            | 0.005467   |            |       |  0.01

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

Total # of neighbors = 132210
Ave neighs/atom = 66.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.051424184853, Press = -1.01576946367611
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8416.475      -8416.475      -8496.6996     -8496.6996      310.47734      310.47734      23401.235      23401.235     -613.03055     -613.03055    
     40000  -8415.0401     -8415.0401     -8498.1499     -8498.1499      321.64349      321.64349      23411.675      23411.675     -1511.5116     -1511.5116    
Loop time of 41.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.067 ns/day, 11.610 hours/ns, 23.925 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    | 41.714     | 41.714     | 41.714     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015037   | 0.015037   | 0.015037   |   0.0 |  0.04
Output  | 3.8702e-05 | 3.8702e-05 | 3.8702e-05 |   0.0 |  0.00
Modify  | 0.062235   | 0.062235   | 0.062235   |   0.0 |  0.15
Other   |            | 0.005505   |            |       |  0.01

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

Total # of neighbors = 131934
Ave neighs/atom = 65.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.092770167307, Press = 0.48074655655418
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8415.0401     -8415.0401     -8498.1499     -8498.1499      321.64349      321.64349      23411.675      23411.675     -1511.5116     -1511.5116    
     41000  -8412.7312     -8412.7312     -8496.5078     -8496.5078      324.2242       324.2242       23383.154      23383.154      689.16016      689.16016    
Loop time of 41.7756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.604 hours/ns, 23.937 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    | 41.693     | 41.693     | 41.693     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015062   | 0.015062   | 0.015062   |   0.0 |  0.04
Output  | 2.6029e-05 | 2.6029e-05 | 2.6029e-05 |   0.0 |  0.00
Modify  | 0.06223    | 0.06223    | 0.06223    |   0.0 |  0.15
Other   |            | 0.005449   |            |       |  0.01

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

Total # of neighbors = 131858
Ave neighs/atom = 65.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.123758596413, Press = 1.6123333201852
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8412.7312     -8412.7312     -8496.5078     -8496.5078      324.2242       324.2242       23383.154      23383.154      689.16016      689.16016    
     42000  -8412.9327     -8412.9327     -8495.8176     -8495.8176      320.77318      320.77318      23366.129      23366.129      2054.2233      2054.2233    
Loop time of 41.9273 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.061 ns/day, 11.646 hours/ns, 23.851 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    | 41.845     | 41.845     | 41.845     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015048   | 0.015048   | 0.015048   |   0.0 |  0.04
Output  | 3.8673e-05 | 3.8673e-05 | 3.8673e-05 |   0.0 |  0.00
Modify  | 0.062213   | 0.062213   | 0.062213   |   0.0 |  0.15
Other   |            | 0.005488   |            |       |  0.01

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

Total # of neighbors = 132014
Ave neighs/atom = 66.007
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.152892227411, Press = -0.259125868158032
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8412.9327     -8412.9327     -8495.8176     -8495.8176      320.77318      320.77318      23366.129      23366.129      2054.2233      2054.2233    
     43000  -8417.2982     -8417.2982     -8497.8287     -8497.8287      311.66137      311.66137      23395.852      23395.852     -478.36844     -478.36844    
Loop time of 41.9316 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.060 ns/day, 11.648 hours/ns, 23.848 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    | 41.849     | 41.849     | 41.849     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015074   | 0.015074   | 0.015074   |   0.0 |  0.04
Output  | 3.8472e-05 | 3.8472e-05 | 3.8472e-05 |   0.0 |  0.00
Modify  | 0.062265   | 0.062265   | 0.062265   |   0.0 |  0.15
Other   |            | 0.005503   |            |       |  0.01

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

Total # of neighbors = 132354
Ave neighs/atom = 66.177
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.200189333596, Press = -1.90898075325385
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 = 6.1
  ghost atom cutoff = 6.1
  binsize = 3.05, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8417.2982     -8417.2982     -8497.8287     -8497.8287      311.66137      311.66137      23395.852      23395.852     -478.36844     -478.36844    
     44000  -8413.0654     -8413.0654     -8495.1504     -8495.1504      317.67736      317.67736      23435.498      23435.498     -2744.6538     -2744.6538    
Loop time of 41.7892 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.068 ns/day, 11.608 hours/ns, 23.930 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    | 41.706     | 41.706     | 41.706     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015079   | 0.015079   | 0.015079   |   0.0 |  0.04
Output  | 3.8312e-05 | 3.8312e-05 | 3.8312e-05 |   0.0 |  0.00
Modify  | 0.062349   | 0.062349   | 0.062349   |   0.0 |  0.15
Other   |            | 0.005512   |            |       |  0.01

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0